Teaching AI To Do Your Work

I migrate WordPress sites every week. I have for years. I built tools to automate most of the migration. A bash utility called _do that handles backups and migrations over SSH. A WordPress plugin called Disembark that syncs files and databases from a source site to a new server. These tools work and are very efficient.

Then I started using Claude Code for my daily work. Not as a code generator. As a coworker. Instead of running the commands myself I now just have Claude run the commands for me.

It started with a single migration.

I was migrating a site to Kinsta using Disembark. The process has about 12 steps. SSH in, download the CLI, connect to the source site, sync files, inspect the backup, rsync wp-content while preserving mu-plugins, import the database, fix the table prefix, convert MyISAM tables to InnoDB, verify everything, handle URLs, then clean up. I have done this hundreds of times.

Instead of running each command, I walked Claude through it. Step by step. “Here is how I connect Disembark.” “Here is how I handle the table prefix mismatch.” “Here is why we preserve the mu-plugins directory.” Claude watched, asked clarifying questions, and took notes.

At the end I said: “Can you remember this for next time?”

That it. Claude documents everything is ready to work.

Claude Code has a persistent memory system.

When I say “remember this,” Claude writes a memory file to disk. It is a markdown file with frontmatter describing what the memory is about and when to use it. These memories persist across conversations. The next time I start a new session, Claude loads its memory index and has full context on how I work.

Here is what a real correction looks like in a session.

That correction became a permanent memory file. In every session since, Claude moves backups to ~/private/ without being asked. One correction. Infinite reuse.

But memory alone is not enough for complex multi-step tasks. That is where skills come in.

A skill is a reusable prompt file that teaches Claude a complete workflow. It lives in ~/.claude/skills/ as a markdown document with phases, commands, edge cases, and decision trees. When I type /disembark-migrate, Claude loads the entire playbook and executes it. It SSHs into the server, downloads the CLI, syncs the site, inspects the backup, handles the database, and cleans up. All I provide is the SSH connection string.

I turned three migration workflows into three skills.

/do-backup generates a full WordPress backup over SSH. I give it a domain. It looks up the SSH connection from the CaptainCore API, runs the _do backup command, and hands me back a download URL. What used to be three commands is now one word.

/do-migrate takes a backup URL and an SSH connection, then streams the backup to the destination server. It handles the shell quoting that always tripped me up. Double quotes for the outer SSH command, single quotes around the backup URL to protect query string characters. Claude never forgets that.

/disembark-migrate is the most complex. Twelve phases. It downloads the Disembark CLI, syncs the source site, inspects the backup for multisite configuration, rsyncs wp-content while preserving Kinsta’s mu-plugins, imports the database, fixes the table prefix, converts MyISAM to InnoDB, verifies the migration, and cleans up after itself. I documented every edge case I have encountered over years of migrations. Now Claude handles them all.

The skill is better than my muscle memory.

Here is the thing I did not expect. Claude runs these migrations more reliably than I did manually. Not because it is smarter. Because the skill document captures every edge case I ever encountered, all at once. When I ran migrations by hand, I would occasionally forget to convert MyISAM tables. Or I would forget to check for multisite constants. Or I would leave the Disembark plugin installed on the destination.

The skill never forgets a step. It runs all twelve phases in order, every time.

Skills are not the only way Claude learned my job.

Alongside the 22 skills I have built, Claude has accumulated 37 memory files about how I work. Some are small corrections. Some are entire workflow playbooks.

A few examples.

When I process my email inbox using wp missive, Claude knows the triage workflow. It searches by category, batch-closes noise first (Google Workspace alerts, Hover domain renewals, Jetpack notifications), then works through the actionable items. It knows that “Security Alert: Injection detected” emails require curling the actual script URL to inspect the JavaScript source. Not just checking that the script tag exists on the page. That distinction matters. I taught it that after it almost missed a real injection by only confirming the tag was present.

A few weeks in, I watched Claude catch itself. It had just started reviewing a fresh batch of injection alerts. I asked it to remember to curl the scripts before closing.

That admission was new to me. Claude not only remembered the memory. It flagged that it had failed to follow it. That kind of self-correction only works when the memory captures why the rule exists, not just the rule.

When I ask Claude to draft an email, it knows to use <br><br> for paragraph breaks instead of <p> tags because Missive’s editor collapses them. It knows to address people by first name only, no “Hi” or “Hello.” It knows to never close a conversation without my explicit approval. Each of these was a correction I made once. Claude remembered and never repeated the mistake.

The correction loop is the real product.

The most valuable part of this system is not the skills or the memories individually. It is the feedback loop.

I work with Claude. Claude makes a mistake. I correct it. Claude saves a memory. Next time, Claude does it right. Over weeks and months, Claude accumulates a detailed model of how I work. Not just what commands to run, but why. Not just the happy path, but the edge cases.

When I told Claude to never leave .bak files in the web root, it saved a memory explaining why (security risk, publicly accessible). When I told it to always include --subject="Re: ..." on email replies, it saved a memory explaining that Missive’s API does not auto-populate the subject. The “why” matters because it helps Claude make judgment calls in new situations it has not seen before.

22 skills later, here is what I have automated.

Site migrations. Backups. Malware cleanup. Security audits. Performance audits. PHP version upgrades across the entire fleet. Plugin security patches deployed to hundreds of sites in parallel. DNS record management. Blog post publishing. Email triage. Bulk WordPress operations across customer accounts. Plugin checksum reviews. Drift scanning across 2,900 sites to find tampered files.

Each of these started the same way. I did the task manually while Claude watched. I corrected mistakes. I said “remember this.” Then I formalized it into a skill.

This is not about replacing yourself.

I still make every decision. Claude does not close customer emails without asking. It does not deploy code changes without confirmation. It does not push to production on its own. The skills handle execution. I handle judgment.

But the execution used to take most of my time. A Disembark migration took 20 to 30 minutes of active terminal work. Now I type /disembark-migrate and provide the SSH string. The whole process runs while I review other work. When it finishes, I verify the results and move on.

The real shift is this: I spent years building tools to make my job faster. _do, Disembark, CaptainCore, custom WP-CLI commands. Those tools still exist. They still work. But now there is a layer on top that knows how to use them all together, in the right order, with all the edge cases handled. That layer is Claude, trained on how I actually work.

Claude documents my business. Now Claude works in my business. I just work on it.