If you run Home Assistant, you know the little update badge. New version available. And if you're like me, that badge brings a jolt of excitement for the new features and a hint of fear that my setup could get bricked or eat hours of work to put back together.
For a long time my process was "skim the release notes and cross my fingers." I'd scroll the blog post, nod at the headline features, glance at the breaking changes section, and convince myself it was fine to proceed. And while I never had a serious blow-up, the doubt never left either: something could go wrong, and I was probably not using (or even understanding) the latest features. This would often lead me to delay updates, and it created a nagging feeling that my smart home was getting dumber.
Don't get me wrong, the HA community is awesome, and the release notes + accompanying blog are solid, but they're just not written about my house and my setup. They'll tell you an attribute is being deprecated, but not that you have four automations quietly depending on it. They'll tell you there's a new way to build dashboards, but not whether it fixes the specific thing that's been annoying you for a year.
The obvious move
Since we are in the age of AI, I did the obvious thing and threw Claude at the problem.
Claude now reads the official release notes, scans the community forums, cross-references against my setup, and tells me what actually matters. The first session went great. I had not upgraded in a long time, but the update went smoothly and I came to learn about the newsish dashboard system and sections. I immediately dispatched Claude and came away with a cool new dashboard with several helpful views.
I closed my laptop feeling clever. A problem that had plagued me for years was seemingly gone. I could confidently upgrade, and adopting new features became a breeze.
Then next month I tried again, and Claude had forgotten everything we did.
The next problem
I had to restart from scratch: Claude didn't know my Home Assistant URL, that I run HAOS rather than a container install, that I access everything through the browser, that I prefer the UI editor over hand-writing YAML, or where my logs and repairs panel live. And I had forgotten all the little tricks I'd used last time to make it work. There had to be a better way...
The tool was capable. It just wasn't smart about me. And re-teaching it my house every single time felt a lot like the thing I was trying to escape.
My first thought was to write a detailed prompt and just save it somewhere, but that felt very 2025. I figured there must be a better way.
And then it hit me: Skills. I decided to build one.
What goes in the skill (and why)
The temptation with something like this is to dump everything you know into a wall of text and call it done. That's not what makes it work. The useful version is closer to a briefing for a sharp new contractor: here's the building, here's how you get in, here's how I like things done, here's where the tools are.
In the end, the skill ended up focused on a handful of things:
The instance basics : the URL, the fact that it's HAOS, and that access happens through an authenticated browser tab rather than an API key sitting in a config somewhere. That last detail shapes everything else, so it goes near the top.
My preferences , stated plainly. Use the UI editor for automations, drop to YAML only when something actually needs it. This is the difference between an agent that works the way I'd work and one that makes choices I'll quietly have to undo later.
Navigation shortcuts : direct links to Settings, Logs, Repairs, Developer Tools, and the rest. Small thing, big payoff. It's the difference between burning tokens hunting through menus and just getting down to business.
Diagnostic workflows : how to read an automation trace, how to reload an integration, how to check an entity's actual state. These are the moves I'd make instinctively and would otherwise have to narrate live, every time.
And the slightly nerdy but crucial bit: how to talk to the API without tripping over CORS. Because access is browser-based, the trick is to run the API calls from inside the already-authenticated Home Assistant tab. Once that pattern is written down, Claude can read entity state and make changes through the same front door the UI uses, instead of clicking around like a person.
None of this took long to assemble. Claude's skill-creator did the heavy lifting, mining my past conversations for the critical 'tricks' I'd already worked out and drafting most of the file for me.
And the best part, because it is a skill, invoking it is a simple slash command - /ha-update
The net: every new session starts already oriented.
I assumed the skill closed the book on the matter, but the real payoff showed up the next time an update actually landed.
The first real test
The update badge appeared. I asked Claude to take it from there.
It pulled the release notes, checked the GitHub release, scanned the community forum for early reports on that specific version and cross-checked everything against my setup. Verdict: a couple of new features not really relevant to me, and a Z-Wave change that had the potential for disruption. And of course, the sensible recommendation to take a backup first. I gave it the go-ahead, so it took a backup, then applied the update. Clean restart.
Then the Repairs panel lit up. Not totally unexpected.
Eight Z-Wave entity deprecation warnings. Home Assistant had renamed a batch of verbose legacy entity IDs to cleaner ones, which is a nice change in theory and a pain-in-the-butt in practice, because every automation pointing at the old names was now pointing at nothing. The old me would have spent hours hunting through automations, grepping for entity IDs and fixing them one at a time, getting it 90% right and finding the last 10% when something silently stopped working.
Instead, because the skill already knew which entities my automations used, Claude worked through all eight in a single pass. Updated the references, cleared the warnings, and the Repairs panel went quiet. Hours of work done in minutes, for the cost of a few tokens.
The part that keeps paying off
Here's what I didn't expect. The context I wrote for vetting updates turned out to be worth far more than that.
The same file that knows my entities and my preferences makes everything faster. Debugging a misfiring automation, the agent already knows where the traces are. Reworking a dashboard, it already knows my layout habits. Chasing down a flaky sensor, it already knows how to query state. I built the context for one job and it quietly improved every other job I do in Home Assistant.
I set out to make one annoying chore less scary. What I actually built was an AI agent that understands my house, and that turned out to be the part that mattered. The updates were just the excuse. Now every job in Home Assistant, the upgrades, the debugging, the "why is this light doing that" at 11pm, is simple and approachable.
Top comments (0)