Shipping UMB.FYI in Ten Minutes with Claude Skills

7 min read

From day one, UMB.FYI has been an exercise in automation. It’s run by one person (me), it goes out every Wednesday, and the only way that’s sustainable is if as little of it as possible relies on me sitting down and doing things by hand.

If you’ve read my 24 Days article you’ll know most of the collection side is automated. Background jobs pull in blogs, videos, podcasts, events and packages, and tips come in from bots on Discord, Mastodon and Bluesky. Then last year I added a workflow engine to take care of the repetitive editing jobs, like checking links still work, spotting duplicates, and assigning categories, emojis and tags.

Even with all that in place though, prepping an issue still took me about 30 minutes every week. And when I looked at where that time went, it was all on the bits I’d never been able to automate.

The Hard to Codify Bits

The things left over weren’t hard work, they were judgement calls. Things like:

  • Processing tips. Someone shares a Mastodon post that links to a blog post. Do I link the post or the blog? Is it from this week, or has an old article resurfaced? Have I already featured it from a feed, maybe as a dev.to cross-post of the same article?
  • Reviewing what the workflow produced. Is that tag actually right, or did a post just mention “forms” once in passing? Is this event still on? Is this package release the same news as that forum post?
  • Spotting what got missed. Not everyone tips, so I’d have a scroll through social to see if anything slipped through.
  • Writing the preheader and the social post. Picking three things that represent the week, and wording them so they fit on the social images.

None of these really have a single right answer, which is exactly why they’re hard to write code for. Every time I tried, I’d end up with a growing pile of special cases that still didn’t quite cover it.

What I eventually realised was that the thing I’d been trying to engineer around, AI’s non-determinism, was actually what made it a good fit here. I didn’t need something that gave the same answer every time. I needed something that could look at a messy, unpredictable input and make a reasonable call, the way I would.

Enter Skills

So I’ve built a set of Claude skills for UMB.FYI, one for each step of my weekly prep.

Here’s what’s in the set:

SkillWhat it does
process-tipsWorks through the tips inbox, finds the real link, checks it’s new, and drafts the item.
create-newsletterCreates the issue from the newsletter blueprint, named and timed for its Wednesday.
newsletter-itemsRuns the workflow, reviews the results, and adds the approved items to the issue.
social-sweepSearches social media for anything the tips missed.
weekly-crypticWrites and checks the minute cryptic puzzle.
newsletter-preheaderPicks three headline items and checks they fit on the social images.
newsletter-linkedinWrites the LinkedIn post that goes out when the issue is sent.
check-newsletterGives the finished draft a final once over before it goes out.
publish-newsletterPublishes the issue, but only when I say so.

And then there’s a prep-newsletter skill that just runs the others in order. So on a Wednesday morning, all I type is “time for todays newsletter”.

The skills don’t talk to the site through a general purpose tool either. They all go through a small shell script that logs in as an Umbraco API user and exposes just the operations they need, like tips, create, add-items or set-preheader. That keeps what the skills can do to the live site nice and narrow.

Rules Learned From History

The most important part of each skill isn’t actually the instructions, it’s the rules file that sits alongside it.

When I first built process-tips, rather than writing the rules from my head, I had Claude go back through a year’s worth of tips and compare each one with what I’d actually featured. If a tip ended up in a newsletter it was a keep, if not it was a drop, and from there it worked out the patterns behind my decisions. Some of them I’d never have thought to write down. For example, in the history, 30 of 31 kept social posts linked to the post itself rather than the thing it pointed at, so the rule is to lean towards the post unless the destination is clearly an article.

The result is a file of rules like this:

## 2. Duplicates

- **Same post, different platform.** Many people post to their own blog
  and cross-post to dev.to, Medium, LinkedIn articles or Hashnode. A link
  or exact-title search won't always catch this, so also:
  - Read the page's `<link rel="canonical">` and `og:url`. Cross-posts on
    dev.to, Medium and Hashnode often point at the original.
  - Look for the same author in recent newsletters and compare titles
    loosely. Cross-posts often tweak the title or drop a subtitle.
- **Same post on Discord and somewhere else.** Never keep the Discord one:
  keep the other platform's post and drop the Discord tip. Discord links
  aren't friendly for readers.

The workflow review has its own rules too. My favourite is the one for tags. The workflow assigns tags by pattern matching, so a post about upgrading that mentions “forms” once in passing comes back tagged umbracoforms. Rather than trying to write a rule for that, the skill has a generated reference of how every tag has been used in past issues, with examples, and it checks each item against those instead. That’s exactly the kind of “does this look like the others?” judgement that’s easy for a person, and really hard to put in code.

And running through all of them is one simple principle:

When torn, flag it. A wrong keep is cheap (Matt sees it in the table).
A wrong drop is invisible.

I’d much rather be asked than have something quietly disappear.

These files also keep learning. If I change a decision during a run, the skill points out which rule that suggests and offers to update it. Tag fixes go into a tag-corrections.md file, and the preheader skill keeps a log of the options it offered me and which one I picked, so over time it gets a better feel for what I tend to go for.

A Human Stays in the Loop

You might be thinking that letting an AI loose on the live site is asking for trouble, and you’d be right to be wary. Which is why every skill stops for my approval before it writes anything.

Each step ends with a single review table, so rather than doing the work myself, my job becomes scanning the table and saying “go”. Anything the skill isn’t sure about gets marked as unsure with a one line reason, and it won’t move on until I’ve made the call. This week, for example, it flagged that a cheat sheet being shared had the same URL as one I featured back in 2024. It had actually been rewritten for Umbraco 17, so I kept it, but it was right to ask.

There are also a few hard lines that go into the skills’ instructions:

  • Nothing is ever published unless I say “publish” in my own words, and even then it asks again.
  • Nothing is ever deleted on the live site.
  • Any credentials come from the environment, never the repository.

Making It Fast

The other half of getting the time down was making sure I wasn’t sat waiting.

The newsletter workflow takes a few minutes to run, so rather than waiting for it, the prep skill starts it in the background and gets on with other things. The social sweep is handed off to a background agent, as reading through a week’s worth of social posts is slow work. Meanwhile I’m picking this week’s puzzle clue. By the time I’ve done that, both are usually finished and ready for review.

The sweep also uses Jev for a first pass. Asking a big model to read every post is slow and expensive, but asking Jev a quick yes or no (“is this about Umbraco news?”) on every post is near instant, and leaves a much shorter list for the more careful read.

The Result

So, how long does it take now? This week’s issue went from “time for todays newsletter” to published in about 12 minutes. That included processing the tips, reviewing 45 items from the workflow, adding 8 more from the social sweep, writing the puzzle, the preheader and the LinkedIn post, and a final check.

Most weeks now land somewhere between 10 and 15 minutes, compared to the 30 or so it used to take me. And more importantly, the time I do spend is on the bits that actually need me, making decisions, rather than clicking around the backoffice.

Wrapping Up

What I’ve found interesting about this is that it isn’t really replacing the automation I already had. The scrapers and the workflow engine are still doing all the heavy lifting, and they should, as those are jobs with right answers. The skills just sit in the gaps that were left, where the answer is “it depends”.

Each round of automation has made UMB.FYI a little easier to run, and this is the first one that’s taken on the bits I thought would always need me. I’m curious to see what’s left to tackle next.

Until next time 👋