Claude

There's something fundamentally different about having an AI agent that can read and modify files directly on your computer, right there in your folders, alongside your code and personal files.

I've been playing with Claude Code lately, and I'm convinced we're witnessing the early days of how personal automation will work in the future.

The "Aha" Moment

The realization hit me when I started using Claude Code for something mundane: cooking. Over a few hours, my mom and I planned two 4-course meals and a turkey in a seemingly effortless manner.

I gave the agent access to a folder. It could read my recipes, modify them, create shopping lists, adjust portions, even remember and save my preferences and workflows. Add nutritional values to a recipe? Done. Missing a recipe? Here are three options. Gluten free version? No problemo. This felt like an assistant living in my file system, evolving with me.

That's when it clicked: this is what personal automation should feel like.

Automating Everything

Once you have an agent with file system access, everything changes. I'm now building several personal projects entirely differently than before:

• Prototyping: I describe what I want, the agent scaffolds it, we iterate in real-time
• Debugging: Point it at a folder, it reads the context, finds issues, suggests fixes
• Documentation: It writes docs by actually reading my code and grounding the output in the real project
• Refactoring: It can see the entire codebase structure and maintain consistency

The feedback loop feels completely different. It becomes collaborative development with something that can see and touch the same files you're working with. Sometimes those files are code. Plaintext and markdown files work just as well.

Mobile Agents with Clawdbot

One of the first concessions I had to make was that the agent runs on my computer. At first, I had to be in front of that machine to interact with my agents. Then the obvious question appeared: what if I have an idea for a project on the go?

Enter Clawdbot. It's a gateway that connects Claude Code to messaging platforms like Telegram, WhatsApp, Discord, and more. It still runs on my machine, has access to my files and context, and I can interact with it from anywhere via my phone.

I named my instance "Chiko" 🌱 and it's become genuinely useful:

• Voice messages: I send voice notes, it transcribes and responds
• Proactive updates: It checks in each morning with ideas or status updates
• Background tasks: I can kick off coding tasks that run overnight. It spawns sub-agents, does the work, and pings me when done
• Daily summaries: It drafts my Basecamp check-ins by checking my GitHub activity, calendar, and email
• Memory: It maintains notes across sessions so it remembers context about my work and preferences

The magic is the combination: an agent with full access to my filesystem, tools, and the ability to spawn other agents. I can dictate a task while walking and wake up to a PR ready for review.

Imagine being at the store and asking your agent to check what ingredients you already have at home by reading your inventory file. Or having an idea for a feature while walking and dictating it to your agent, which immediately opens the relevant files and starts planning the implementation.

This is the bridge between "computing" and "living": agents that follow you throughout your day, including the moments away from a keyboard.

MCPs: Giving Agents Superpowers

Then there's the Model Context Protocol (MCP). This is where things get wild.

MCPs let you give your agents specific capabilities and skills. Want your agent to control your smart home? Check your calendar? Query your database? Send emails? MCPs make it possible.

The pattern I'm seeing emerge:

1. Context (file system access + relevant data)
2. Capabilities (MCPs that let the agent interact with specific tools/services)
3. Access (natural language interface to orchestrate everything, from anywhere)

Put those three together, and you have something that starts to feel like a personal operating system.

What This Means

I think we're at the beginning of a major shift in how we interact with our computers.

For years, automation meant:

• Learning scripting languages
• Setting up complex workflows
• Maintaining brittle integrations
• Doing things the computer's way

AI agents understand natural language, read and write files, and use the right tools through MCPs. Automation becomes conversational.

You describe what you want. The agent figures out how to do it. You iterate together. It learns your patterns and preferences over time.

This expands beyond writing code faster. It lets you delegate entire categories of tasks to something that can work alongside you, in your environment, with your context.

Getting Started

If you're curious about this:

• Try Claude Code: give it access to a small project folder and see what happens
• Check out Clawdbot if you want mobile access to your agents via Telegram, WhatsApp, or other messaging platforms
• Explore AgentSkills to understand how to package a workflow into a repeatable process that an agent can execute.
• Start small: automate one annoying task in your life

The future of personal automation augments what we can do, reduces friction, and lets us focus on the interesting problems while delegating the tedious stuff.

And honestly? It's just fun to have an intelligent assistant living in your computer, ready to help with whatever you're working on.