Getting Started

If you've read through this site and thought "I want something like this," here's a practical path. You don't need to build everything at once — each layer is useful on its own.

Level 1: The Constitution

Time: 1–2 hours. Cost: $0.

Start with a single markdown file that contains your rules and preferences for AI interactions. Include:

• Hard rules (things that must never happen)
• Your project structure conventions
• Where credentials live
• How you want to be communicated with

Save it somewhere consistent. At the start of every AI session, tell the tool to read it. Even without any automation, this dramatically improves consistency.

The constitution is the highest-leverage thing in this entire system. Everything else builds on it.

What to include in v1

• 3–5 hard rules that matter to you (identity separation, credential safety, PR requirements)
• A brief "about me" section so the AI has context
• Your preferred communication style
• File paths to important directories

Level 2: Structured Knowledge

Time: A weekend. Cost: Obsidian is free for personal use. Multi-machine use requires a deliberate synchronization strategy; I use Obsidian Sync for the vaults.

Set up Obsidian (or any markdown-based knowledge tool) with a folder structure that mirrors your life:

AI/                  ← constitution and cross-cutting context
Work/                ← employer, clients, side business
Personal/            ← personal projects, life admin

Within each project, create an AI/ folder with:

• MEMORY.md — what the AI needs to know about this project
• References/ — stable facts (API docs, conventions, credentials locations)

Now when you start a session about a specific project, you can tell the AI to read both the global constitution and the project-specific context. Two files, full context.

Level 3: AI-Assisted Development Workflow

Time: A few hours. Cost: A subscription to a capable AI coding agent.

Install a coding-focused CLI tool (I use Claude Code and Codex) and set up a basic development workflow:

1. Create one global constitution file with your hard rules and session-start instructions
2. Add repo-local agent instructions (AGENTS.md, project memory, or the equivalent your tools read automatically)
3. Add a deterministic session bootstrap that loads the required context and verifies the execution host
4. Establish the PR convention — all non-trivial code changes go through branches and PRs
5. Require independent review from different AI providers or model families

This gives you AI-assisted development with built-in review gates. The AI writes the code, another AI reviews it, and you review the outcome.

Two practical rules matter more than people expect:

• make every coding session read the constitution first
• require root-cause fixes instead of mock-data shortcuts or simplified replacement components

Level 4: Persistent Assistant (OpenClaw)

Time: A weekend to set up. Cost: Hardware + an AI subscription.

This is where things get interesting. Set up OpenClaw on an always-on machine:

1. Get a machine — a Mac Mini, a Raspberry Pi, a cloud VPS, whatever stays on
2. Use a capable coding agent such as Claude Code or Codex to install and document OpenClaw (see security note below)
3. Configure a model provider and an explicit fallback policy
4. Set up a Telegram bot for interaction
5. Create your workspace files (identity, memory, tools)

Start with one or two agent-native jobs — perhaps an attention briefing or infrastructure summary. Keep deterministic checks as ordinary scripts rather than spending model tokens on work that does not require judgment.

Security is critical

It's very easy to install OpenClaw insecurely. A persistent AI assistant with access to your credentials, email, and infrastructure is a powerful tool — and a serious attack surface if misconfigured.

My approach was to have a coding agent perform the installation from a locked-down starting point, document every consequential decision, and verify the result behaviorally. For example, browser access began with a strict domain allowlist and expanded only as specific needs arose.

More broadly, I use coding agents as system administrators for setup, hardening, maintenance, and recovery. Firewall rules, SSH keys, services, and certificates can all be managed this way, but important changes still need explicit scope, backups, verification, and an independent review path. An AI knowing common practices is useful; it is not evidence that the resulting system is secure.

Don't install OpenClaw by following a quick-start guide and hoping for the best. Start locked down. Open things up deliberately, one capability at a time.

Cost tip

Prefer subscription-backed access where the provider supports it, then use metered APIs or open models where they are operationally appropriate. Route work by semantic role and capability rather than embedding one provider or version into every job. This keeps costs predictable while preserving independent review and fallback options.

Hardware options

Level 5: Multi-Machine Mesh

Time: A few hours. Cost: Tailscale is free for personal use. Syncthing is free. Obsidian Sync remains required for the vaults.

Connect your machines:

1. Install Tailscale on every machine — instant mesh VPN
2. Use Obsidian Sync to keep the Obsidian vaults themselves in sync
3. Set up Syncthing to sync the broader runtime filesystem between machines (credentials, runtime scripts, shared transfer folders)
4. Configure SSH key access so AI tools can reach other machines

Now your AI assistant on one machine can SSH into another, your vault updates propagate through Obsidian Sync, and the non-vault runtime state propagates through Syncthing.

Level 6: Full Automation

Time: Ongoing. Cost: Varies.

At this point you have all the pieces. The final step is connecting them:

• Set up scheduled jobs for recurring tasks (monitoring, email, digests)
• Separate deterministic scripts from work that genuinely needs agent judgment
• Register each recurring job with an owner, scheduler, delivery route, state policy, and model role
• Turn repeated interactive workflows into reusable shared skills
• Add domain-restricted web browsing for research tasks
• Deploy instances for family members or colleagues

Tips from Experience

Start with the constitution. It's the foundation. Get it right before adding complexity.

One thing at a time. Add a new capability, live with it for a week, refine it, then add the next. Rushing to build everything at once leads to a fragile system.

Credentials from day one. Establish your credential management approach early. Retrofitting security into a running system is painful.

Document as you go. When the AI does something unexpected, decide whether the lesson belongs in project memory, a reusable skill, an operational runbook, or a constitutional rule. Treat surprises as system feedback, not isolated incidents.

Model policy over model names. Models change too quickly to hardcode everywhere. Define the roles you need, map providers and current models centrally, and make jobs reference those roles.

The human stays in the loop. The goal isn't to automate yourself out of the process — it's to handle the mechanical parts so you can focus on the parts that require your judgment. Keep review gates. Keep hard rules. Keep the ability to say no.