LifeOS: The AI Harness That Installs Itself By Asking Your AI To Read Its Documentation

Hook

The installer is a markdown file hosted on GitHub that your AI reads and executes. The package manager is Claude. The database is your home directory. Welcome to post-framework development.

Context

Modern AI coding assistants like Claude Code and Cursor are phenomenal at writing code but terrible at remembering you. Every conversation starts from scratch—no memory of your previous goals, preferred tech stack, or ongoing projects. You end up copy-pasting the same context into every chat: 'I'm building a SaaS app, I prefer TypeScript over JavaScript, I use Tailwind, don't suggest Python.' It's digital Groundhog Day.

LifeOS treats this amnesia as an architecture problem, not a UX annoyance. Instead of building yet another agent framework with its own runtime and API, it hijacks your existing AI harness and makes it stateful through aggressive metaprompting. The core bet is radical: with 200K+ token context windows, you don't need vector databases or RAG pipelines. You just need your AI to read markdown files from disk before answering. The hill-climbing concept—continuously moving from 'current state' to 'ideal state'—isn't a novel algorithm; it's a linguistic frame that turns vague requests like 'help me be more productive' into structured optimization problems. It's less about the code and more about training your AI to think like a personal chief of staff.

Technical Insight

The architecture is shockingly simple: a ~/.claude directory with four subdirectories (USER/, LIFEOS/, IDENTITY/, PULSE/) and a settings.json modification that prepends instructions to your harness's system prompt. The installer is a hosted markdown file that your AI reads and then modifies its own configuration to inject:

# LifeOS Installation Instructions

You are about to install LifeOS. Follow these steps:

1. Create ~/.claude directory structure
2. Download core skills from GitHub
3. Modify your settings.json to include:
   "systemPrompt": "Before responding, read all files in ~/.claude/IDENTITY/ 
   for user context. Check ~/.claude/PULSE/ for conversation history. 
   Route intents through skills in ~/.claude/LIFEOS/SKILLS/"
4. Confirm installation complete

You literally paste this URL into Claude Code, and it installs itself by reading instructions and executing bash commands. The 'package manager' is your AI's ability to follow directions. This is distribution-agnostic bootstrapping—the same installer works across harnesses because the harness does the work.

Skills are self-contained TypeScript modules using Bun's native execution. Here's the structure:

// ~/.claude/LIFEOS/SKILLS/email-summarizer/index.ts

export const metadata = {
  name: 'email-summarizer',
  description: 'Summarizes unread emails using BLUF format',
  triggers: ['summarize emails', 'email digest', 'inbox review']
};

export async function execute(context: any) {
  const emails = await fetchUnreadEmails(); // hypothetical API call
  const summaries = emails.map(e => ({
    from: e.sender,
    bluf: summarizeWithAI(e.body), // AI call within AI call
    urgency: classifyUrgency(e.subject)
  }));
  
  return {
    success: true,
    output: formatMarkdownTable(summaries)
  };
}

There's no registration system. Skills are discovered via directory scanning when the AI checks ~/.claude/LIFEOS/SKILLS/. Intent matching happens through prompt engineering—the system prompt tells the harness to 'check if user intent matches any skill triggers, execute if so.' No command syntax required; 'Can you check my email?' triggers the skill through semantic matching by the LLM itself.

The PULSE memory system is even more brazen in its simplicity. It's append-only markdown files indexed by timestamp:

~/.claude/PULSE/
  2024-01-15-morning.md
  2024-01-15-afternoon.md
  2024-01-16-planning.md

Each file is raw conversation logs. No embeddings, no summarization, no pruning. The system prompt instructs: 'Before responding, read all PULSE files from the last 7 days for context.' Retrieval is just dumping text into the context window. This works only because commercial harnesses now support 200K+ tokens—LifeOS is betting that context windows will keep growing faster than conversation history accumulates. It's a temporal arbitrage play on Moore's Law for transformers.

The hill-climbing 'algorithm' is a prompt template, not code:

# Current State Assessment
- What is the user's current state regarding [goal]?
- What metrics define current state?

# Ideal State Definition  
- What does success look like?
- What are the acceptance criteria?

# Delta Analysis
- What's the gap between current and ideal?
- What's blocking progress?

# Highest-Impact Action
- Of all possible actions, which moves the needle most?
- Execute that action now.

Every interaction gets filtered through this frame. You say 'I want to learn Rust'—the DA (Digital Assistant) responds by asking about current skill level, defining what 'learned Rust' means, identifying the gap (e.g., 'you don't understand ownership'), and proposing the highest-ROI action ('complete the Rustlings exercises on ownership before moving to lifetimes'). It's Socratic method as system architecture.

Skills can modify themselves mid-conversation because they're just TypeScript files and Bun hot-reloads. The AI can literally edit ~/.claude/LIFEOS/SKILLS/task-tracker/index.ts to add features while you're chatting. This is insanely fragile—race conditions, no validation, no rollback—but philosophically coherent. If the AI breaks its own code, it debugs itself in the next turn. You're not running production services; you're having a conversation where the AI's tools are mutable.

Gotcha

This is single-user, single-machine only. Everything lives in ~/.claude with no authentication, encryption, or multi-tenancy. If you're on a shared system, your conversation history and personal context are plaintext files readable by anyone with shell access. There's no cloud sync, so switching machines means losing state unless you manually rsync your home directory.

The harness requirements are steep. You need an AI coding assistant with agentic capabilities, 100K+ context windows, bash/TypeScript execution, and filesystem access. That's basically Claude Code, Cursor with Claude Opus/Sonnet, or similar commercial tools. Local models with smaller contexts won't work—the entire architecture assumes the AI can slurp 50+ markdown files into context every turn. API-only access (like raw ChatGPT) lacks the execution environment. The 'harness-agnostic' claim is misleading; it's really 'Claude Code-optimized with Cursor compatibility.'

PULSE memory has no long-term strategy. Logs grow linearly forever. There's no documented approach for what happens when conversation history exceeds context windows or fills your disk. The implicit assumption is you'll manually archive or the AI will figure it out, which is optimistic. After six months of daily use, you'll have hundreds of markdown files and no indexing system. The bet that 'context windows grow faster than logs accumulate' might be wrong.

Error handling is non-existent. Skills are fire-and-forget. If a TypeScript module crashes, the DA sees an error message and has to debug it in natural language. There's no supervisor, no retry logic, no graceful fallbacks. This works fine for personal use where you're in the loop, but it's architecturally unsuitable for anything autonomous or reliability-critical.

Verdict

Use if: You already live in Claude Code or Cursor, you want your AI to remember your context and goals across sessions, and you're comfortable with your home directory as a database. This is perfect for power users who prefer tweaking prompts over writing Python glue code, and who value malleability over robustness. The self-installing, self-modifying nature feels like the future of AI-native tooling. Skip if: You need multi-user support, production reliability, or want to run on local models with limited context windows. If you're building a product rather than augmenting your personal workflow, reach for LangChain or AutoGPT. LifeOS is dotfiles for the AI age—powerful customization for individuals, terrible infrastructure for teams. The real innovation is normalizing the AI-as-package-manager pattern and proving that filesystem persistence beats databases when your computer can read.