Every heist movie starts with a specialist. You need the person who can hear the tumblers click inside a vault or the one who can ghost through a laser grid. For the last two years, my Home Assistant server at The Panorama, my home here in Loja, Ecuador, has been my own private vault. But let’s be honest: it got messy. It was crowded with the digital wreckage of abandoned experiments, layers of conflicting reconfigurations, and a log file that read like a coroner’s report.
I decided it was time to bring in a specialist. I realized that to truly clean up the wreckage, I had to change my approach. I moved beyond standard troubleshooting and turned to a large language model (LLM) to act as a technical consultant. I stopped treating AI as a search engine and started treating it like a partner in crime. This meant letting it inside the vault to see the blueprints for itself. Welcome to my grand experiment. I Gave Claude AI Access to My Home Assistant Server. Here is What I Learned.
Casing the Joint
The first thing I learned, is that Claude’s free models won’t cut it for a job this big. I tried using AI for Home Assistant help about a year ago and walked away unimpressed. The responses were generic, and the code was often broken. I realized that to get the depth of analysis I needed, I had to go with Claude Pro. The $20 monthly investment was less about the faster response times and more about the ability to create “Projects” which provide you with a massive context window. This allowed me to upload my entire configuration as a single, coherent body of knowledge rather than feeding it scraps of code one at a time.
Setting up the partnership required a methodical approach. I didn’t just start chatting. First, I crafted a set of custom instructions to define exactly how I wanted to work. Claude actually suggested interrogating my previous AI assistant, Gemini. It generated a specific prompt that sucked out all my old instructions and preferences from Gemini. I read and refined these carefully. I wanted Claude to know the technical specifics of my server, but I made sure to scrub anything about my personal shopping habits and unrelated hobbies.
Once the personality was established, I created a dedicated “Project” in Claude. This is where the heist really began. A project allows the AI to maintain a persistent memory of your specific files. I loaded the project with every piece of YAML I’ve written over the last two years. This included automations.yaml, scripts.yaml, configuration.yaml, as well as my packages, template sensors, shell commands, and all of my AppDaemon scripts. By giving the AI the full picture, I ensured it wouldn’t just fix a single line of code while breaking any others it couldn’t see.
However, a mastermind knows the blueprints provided by the builder are never the whole story. To really see how the house is wired, you have to look at the hidden registers. I asked Claude if there was more I could provide to give it a better “eyes-on” view of the system. It confirmed that seeing my full entity list and dashboard configuration would be a game-changer.
The Break-In: Extracting the Registry
I quickly realized that to do a proper audit, we needed the internal data hidden in the .storage directory. This is where Home Assistant keeps the real secrets. Most users never touch these files because they are managed by the UI. If you want to find out why a specific entity is “missing” or why a dashboard card is broken, you have to go into the basement.
I reached for the Advanced Terminal & SSH add-on. The standard version simply does not give you the access you need to the underlying filesystem. It is like trying to pick a lock with a toothpick. You need heavy tools for this part of the heist.
Before running these commands, you must disable bracketed paste mode by typing unset zle_bracketed_paste in the terminal. If you don’t, the terminal might mangle the code as you paste it in. These scripts use Python to parse the internal JSON registries and generate clean, readable export files in your /config/ folder. Once they exist, you can download them and feed them directly into the Claude Project.
The Entity List
This script exports every registered entity, their platform, their current state: on/off, unavailable, unknown, and even if they are currently disabled. It allows Claude to see that you have a light.kitchen_sink that hasn’t been online in six months, or an entity that is no longer being served by its integration. This is the first step in identifying the “orphans” that are haunting your registry.
python3 -c "import json;data=json.load(open('/config/.storage/core.entity_registry'));entities=data['data']['entities'];output=[{'entity_id':e['entity_id'],'name':e.get('name') or e.get('original_name',''),'platform':e.get('platform',''),'disabled':e.get('disabled_by')} for e in entities];output.sort(key=lambda x:x['entity_id']);json.dump(output,open('/config/entity_list.json','w'),indent=2);print(f'Done. {len(output)} entities exported.')" |
The Dashboard Blueprints
This pulls your Lovelace storage files. It tells Claude how you actually look at and interact with your home. It reveals which entities you actually care about and which ones are just digital clutter left over from cards you deleted months ago.
python3 -c "import json,os;files=[f for f in os.listdir('/config/.storage/') if 'lovelace' in f.lower()];print('Found:',files);result={};[result.update({f:json.load(open('/config/.storage/'+f))}) for f in files];json.dump(result,open('/config/lovelace_export.json','w'),indent=2);print('Done')" |
The Helper Registry
This catches every input_boolean, timer, and helper you created through the UI. In the past, Claude would often suggest a helper that already existed because it couldn’t see the UI-managed entities. Now, it has the full inventory. This prevents you from creating three different “vacation mode” switches by accident.
python3 -c "import json,os;types=['input_text','input_boolean','input_button','input_select','input_datetime','input_number','timer'];result={};[result.update({t:json.load(open('/config/.storage/'+t))}) for t in types if os.path.exists('/config/.storage/'+t)];json.dump(result,open('/config/helpers_export.json','w'),indent=2);print('Done')" |
Scrubbing the Scene
With the data in hand, the cleanup montage began. I started pasting my raw logs into the chat. Every morning, we would look at the errors that popped up overnight. We found “traitor”, integrations that I had configured months ago during a weekend of experimentation but never actually used. They were just sitting there, polling servers, eating resources, and spitting out connection errors. I fired them immediately.
We found faulty templates that “worked”, but were causing intermittent lag. For example, my motion-activated lights had been feeling sluggish for weeks. It turns out a template sensor in a completely unrelated package was failing every time the light turned on. This caused a momentary CPU spike that delayed the Zigbee command to the light bulb. Once the log noise was silenced, the lights became snappy again. It felt like the server finally had room to breathe.
Claude helped me find orphaned template sensors and scripts that were no longer tied to any automation. We went through these one by one. I explained that over two years, I had written sensors, automations, scripts, and even AppDaemon apps, only to remove them when I found a better way. Claude helped me identify the remnants of these “old ways.” We didn’t just delete them. We looked at why they were there and decided if the functionality was worth resurrecting in a cleaner way.
The Big Score: The Front Door Masterpiece
Our most impressive “heist” was a total reimagining of my front door security. For over a year, I had two separate, clunky systems watching the entryway camera.
The first automation was a legacy setup that watched for motion, saved a snapshot, and sent it to an LLM. Its only job was to respond with “ACTIVITY” or “CLEAR.” If activity was found, a 90-second timer started causing a dashboard card to pop up the snapshot image. It worked, it was fast, but it was basic.
Later, I added voice assistants and wanted my home to speak. I wrote a second automation that captured a five-second video and sent it to a more powerful LLM for a more detailed description. This one was complex, with retry logic and fallbacks if the primary LLM failed.
Each operation had a specific role. One was the quick-response scout that flashed a snapshot on the dashboard before the visitor even reached the door. The other was the heavy-duty investigator, a video analysis script that managed the complex logic of my voice assistants. They both did their jobs, but they were tripping over each other in the logs.
Now, when motion is detected, the system captures both a snapshot and a video in parallel. It processes the snapshot first because snapshot analysis is nearly instant and very cheap. If the snapshot analysis returns “CLEAR,” the automation stops right there. We don’t waste time or money analyzing the video of a swaying tree branch. But if it sees “ACTIVITY,” it then sends the already-captured video to the more powerful LLM. The voice assistant speaks the description, the dashboard pop-up the image, and the whole thing happens even faster than before. This is the difference between knowing “someone is there” and knowing “the delivery driver just left a package.”
The New Security Protocol: Debugging in Silence
The old way I debugged complex scripts was loud and messy. I used persistent notifications and a small army of input_booleans to track where an automation was in its logic. It was having a security alarm that went off every time a cat walked by. It cluttered the UI and made it impossible to see real errors.
We swapped the loud alarms for a silent comms channel. I now have a debug_enabled boolean variable. When I am working on a script or a new automation, I flip that switch. Inside the automation code, I define a variable to hold this debug state. If the automation then calls a dependent script, that script inherits the state of the debug variable, ensuring the entire crew stays on the same silent frequency and keeps the narrative of the heist perfectly synchronized in the logs.
If debug_enabled is true, the automation writes detailed “checkpoints” into the Home Assistant info logs. It records variable contents, sensor states at the time of execution, and the specific logic paths taken. This allows me to see the entire “story” of an automation’s execution in the logs without a single notification popping up on my phone. When I am satisfied, I flip the switch off, and the server goes back to silent, efficient operation.
Best of all, these log entries survive a server restart, unlike automation traces and persistent notifications, and can be analyzed days later.
The Final Cut
A few weeks in the trenches with Claude showed me the gap between a generalist and a specialist. Other models often trip over the basic syntax of Home Assistant. They hand you code that looks fine until you try to save it and the UI screams in red text. Or they use old platforms that have been dead for years. Claude is different. It nails the indentation on complex choose: blocks and respects the move from platform: to trigger: without being reminded.
But even the best safecracker needs a boss on the outside. Claude is brilliant, but does not live in my house. It might suggest a logic path that is mathematically perfect but physically impossible. I had to stay in the van, eyes on the monitors, making sure the AI understood the intent of the mission before I let it touch the wires. You don’t hand over the keys and go to bed if you want to get away with the score.
The Panorama is now humming. The logs are silent for the first time in months. The response times are down and the clutter is gone. This wasn’t just about fixing broken code. It was about refining the logic of the entire house. Claude forced me to look at every automation and ask if it was actually helping or just a ‘cool’ experiment dragging down the CPU. We didn’t just clean the vault; we reorganized the entire take.
If your Home Assistant setup has started to feel like a digital attic, maybe it is time to bring in some help. Just have your blueprints ready and your terminal open. When the job is done and the logs come up clean, you’ll realize the heist was worth the effort. The specialist did their part, but the final cut was always mine.