A Guide to Building Personal AI Infrastructure

Based on @DanielMiessler's Personal AI Infrastructure (PAI) framework. Start with yourself, not with tools. Before choosing any AI tool, take time to understand your goals, beliefs, and working style. Architecture design is far more important than model selection. A good context management system with an average model often outperforms a top-tier model without context.

Source: github.com/danielmiessler/Personal_AI_Infrastructure

The starting point of the PAI framework is not "how to better use AI tools," but a deeper question—most people's creative potential has never been truly activated. The ultimate goal of an AI assistant is not to help you reply to emails or summarize documents, but to help you discover, clarify, and persistently pursue your life goals.

Ordinary AI chat tools (like ChatGPT, Claude) are stateless: each conversation starts from scratch, not remembering who you are, what you are doing, or where you want to go. PAI's core proposition is to upgrade AI from a "one-time Q&A tool" to a Digital Assistant (DA) that continuously learns and deeply understands you.

This digital assistant has three key characteristics:

• Goal-oriented: Always operates around your vision and goals, not around tools or technology
• Continuous learning: Extracts signals from every interaction, constantly improving its understanding of you
• Deep context: Understands your preferences, history, thinking patterns, and current challenges

TELOS is the cornerstone of the entire PAI framework. It builds a complete personal profile through 10 Markdown files, allowing the AI to understand your full picture at any moment.

2.1 Ten Core Files

2.2 Why This Matters

When your AI assistant reads these 10 files, it is no longer a generic chatbot but a "colleague" who understands your background. It knows what you are doing, what you want, and how you think. This means you don't have to re-explain your situation in every conversation—the AI already knows.

2.3 Practical Advice

You don't need to write perfectly from the start. Even 3-5 sentences per file is fine. Over time, you will continuously supplement and revise. The key is to first set up this framework and let iteration happen naturally.

TELOS defines "who you are," while the memory system records "what happened" and "what was learned." PAI adopts a three-layer memory architecture:

3.1 Hot Memory

Function: Captures immediate signals from recent interactions. Includes preferences in current conversations, decisions just made, recent feedback and evaluations. Hot memory is short-term, helping the AI maintain coherence within the current session.

3.2 Warm Memory

Function: Stores mid-term accumulated patterns and insights. For example, frequently used workflows, emerging interest directions, changes in work focus over recent weeks. Warm memory helps the AI identify trends and habits.

3.3 Cold Memory

Function: Preserves long-term knowledge and historical experience. Includes key decisions, major lessons, and long-term preferences from months or years ago. Cold memory ensures the AI does not lose the wisdom you have accumulated.

3.4 Signal Capture Mechanism

Every interaction generates signals, including your ratings and feedback, emotional changes, success or failure outcomes, and explicitly expressed preferences. These signals are classified and stored in different layers of memory, forming a continuous learning loop.

PAI has a very pragmatic judgment framework for "when to use AI."

4.1 Decision Priority Chain

Goal → Code → CLI → Prompt → Agent Skills

The core logic of this hierarchy is determinism first:

1. Goal: First clarify what problem you are solving.
2. Code: If it can be solved with deterministic code, use code—the result is 100% predictable.
3. CLI tool: Package code into command-line tools for easy reuse.
4. Prompt: Only introduce AI prompts when intelligent judgment is needed.
5. Agent skills: The highest level, encapsulating prompts into reusable agent capabilities.

4.2 Why Not Use AI Directly?

AI models are probabilistic—the same prompt can produce different results. For problems with deterministic solutions (format conversion, data calculation, file operations), code is more reliable than AI. Only when understanding, reasoning, or creativity is required is it worth using AI's probabilistic capabilities.

4.3 Modular Design of Skills

Each skill is an independent module, following the UNIX philosophy—do one thing and do it well. Skills can be combined to form complex workflows.

5.1 Two Core Directories

PAI/
├── USER/          ← All your personalized content
│   ├── identity/  ← Name, voice, personality
│   ├── preferences/ ← Tech stack, tool preferences
│   ├── workflows/ ← Workflow definitions
│   ├── skills/    ← Custom skills
│   ├── hooks/     ← Event hooks
│   └── memory/    ← Memory data
└── SYSTEM/        ← PAI infrastructure code

5.2 Why Separate?

This design solves a key problem: when the system is updated, your personalized configuration will not be overwritten. Your identity, memory, and workflows are your assets, independent of the underlying tool's version iterations.

5.3 Six Layers of Customization

Principle 1: User-Centric All design revolves around the user's goals and needs, not technological possibilities.

Principle 2: Scientific Method as the Fundamental Algorithm "Hypothesis → Experiment → Measurement → Iteration" is the meta-method for solving all problems. Don't guess; verify.

Principle 3: Clear Thinking First Good prompts come from clear thinking. Before writing a prompt, figure out what you actually want.

Principle 4: Architecture Over Model Don't obsess over GPT-4 vs. Claude—system design (context management, memory, workflow) is far more important than model choice. A good architecture can work with any model.

Principle 5: Deterministic Infrastructure Use templates, fixed processes, and structured outputs to reduce AI unpredictability. Let probabilistic AI run on deterministic rails.

Principle 6: Code Over Prompt If a problem can be solved deterministically with code, don't give it to probabilistic AI.

Principle 7: Spec/Test/Evaluation First First clearly define what you want (spec), how to judge success (test), and how to measure quality (evaluation), then implement.

Principle 8: UNIX Philosophy Each component does one thing and does it well. Components are combined through clear interfaces.

Principle 9: Engineering Discipline Treat AI infrastructure as production-grade software—with version control, tests, and documentation.

Principle 10: CLI as the Preferred Interface The command line is faster, more scriptable, and easier to automate than GUI.

Principle 11: Decision Hierarchy Goal → Code → CLI → Prompts → Agents, progressing from deterministic to probabilistic.

Principle 12: Skill Management Modular capabilities that automatically route to the appropriate skill based on context.

Principle 13: Memory System Capture everything worth knowing to form the basis of continuous learning.

Principle 14: Agent Personalization Different agents have different personalities and strengths, like different roles in a team.

Principle 15: Science as Meta-Loop Continuously run the "Hypothesis → Experiment → Measurement → Iteration" loop to keep the system evolving.

Principle 16: Allow Saying "I Don't Know" Explicitly allow the AI to admit uncertainty. This is far more valuable than making things up.

7.1 Design Philosophy The goal of the security system is to protect users without hindering workflows. Good security design should be almost invisible while firmly blocking dangerous operations.

7.2 Permission Verification Every operation goes through permission checks. Dangerous operations (such as deleting files, sending sensitive information) require explicit confirmation. The system should avoid crude toggles like "skip all permission checks."

8.1 What Are Hooks Hooks are actions automatically triggered when specific events occur, similar to "if... then..." rules.

8.2 Typical Events

• Session start: Load user context, check to-do items, show daily summary
• Before tool execution: Verify permissions, record operation intention
• After tool execution: Capture result signals, update memory
• Session end: Save learning outcomes, generate session summary

8.3 Value Hooks transform the AI assistant from "passive response" to "proactive service." Instead of only answering when asked, it proactively offers help at the right moments.

Phase 1: Build Identity Foundation (Week 1)

1. Create a folder as the root of your "AI infrastructure"
2. Create 10 Markdown files following the TELOS framework
3. Write just 3-5 sentences per file, don't aim for perfection
4. Focus on MISSION.md, GOALS.md, and PROJECTS.md

Phase 2: Build Persistent Context (Weeks 2-3)

1. Integrate TELOS files into system prompts or context files for AI conversations
2. Create a simple log file to record key takeaways after each important interaction
3. Start distinguishing hot/warm/cold memory—which information is temporary and which is long-term

Phase 3: Develop Common Skills (Weeks 4-6)

1. Identify your 3-5 most frequent workflows
2. Write a standardized prompt template for each workflow
3. Automate parts that can be automated with scripts
4. Encapsulate prompts + scripts into reusable "skills"

Phase 4: Establish Feedback Loop (Ongoing)

1. Briefly evaluate result quality after each AI usage
2. Regularly review TELOS files, update goals and projects
3. Analyze which skills work well and which need improvement
4. Iterate continuously—this is a never-ending process

Key Takeaways

• Start with yourself, not with tools. Before choosing any AI tool, take time to understand your goals, beliefs, and working style.
• Architecture design is far more important than model selection. A good context management system with an average model often outperforms a top-tier model without context.
• Determinism first, probabilistic supplement. Use code for what can be solved deterministically, only introduce AI when intelligent judgment is needed.
• Continuous learning is the core value. A static AI assistant is just a tool; a learning AI assistant is a partner.
• Start simple, allow iteration. Don't need to get it right in one go. First build a minimal viable TELOS framework, then refine it through use.

This document is compiled from Daniel Miessler's Personal AI Infrastructure project, combined with practical advice. The original project is built with TypeScript and Bun runtime, natively integrated with Claude Code.