ai-os-blueprint（AI 操作系统蓝图）

AI OS Blueprint

Framework: The OS Stack Scorecard *Worth $500/hr consultant time. Yours for $39.*

What This Skill Does

Takes you from "I use Claude like a chatbot" to "Claude is my operating system." Covers persistent memory, skill architecture, context hooks, and sub-agent routing. Includes a full audit of your current setup with a scored gap analysis and rebuild plan.

Problem it solves: The jump from ChatGPT user to AI-native operator is a mindset shift, not just a tooling upgrade. Most people add one automation at a time and wonder why nothing compounds. This blueprint gives you the architecture that makes everything stack.

The OS Stack Scorecard

A diagnostic framework that audits your current AI setup across 5 layers and produces a prioritized rebuild plan. Score your stack, find the bottleneck, fix it first.

The 5 Layers of an AI OS

┌──────────────────────────────────────────────┐
│  LAYER 5: OUTPUTS & INTEGRATIONS             │
│  (Where does the work land?)                 │
├──────────────────────────────────────────────┤
│  LAYER 4: AGENT ROUTING                      │
│  (Who does what work?)                       │
├──────────────────────────────────────────────┤
│  LAYER 3: SKILL ARCHITECTURE                 │
│  (What capabilities are installed?)          │
├──────────────────────────────────────────────┤
│  LAYER 2: CONTEXT & MEMORY                   │
│  (What does the agent know?)                 │
├──────────────────────────────────────────────┤
│  LAYER 1: FOUNDATION                         │
│  (What tools are connected?)                 │
└──────────────────────────────────────────────┘

Fix Layer 1 before Layer 2. Fix Layer 2 before Layer 3. Etc. Skipping layers is why most AI setups plateau.

OS Stack Scorecard: Full Audit

Layer 1 — Foundation Audit

Score each item 0-2:

Layer 1 Score: ___ / 10

If Layer 1 < 6: Stop. Fix foundation before anything else. → Install MCP Server Setup Kit (sold separately) to fix this layer.

Layer 2 — Context & Memory Audit

Score each item 0-2:

Layer 2 Score: ___ / 10

If Layer 2 < 6: Agent has amnesia. Everything you teach it, it forgets. → See Memory Architecture section below.

Layer 3 — Skill Architecture Audit

Score each item 0-2:

Layer 3 Score: ___ / 10

If Layer 3 < 6: You're reinventing the wheel every session. → See Skill Architecture section below.

Layer 4 — Agent Routing Audit

Score each item 0-2:

Layer 4 Score: ___ / 10

If Layer 4 < 6: You're using a supercomputer like a calculator. → See Agent Routing section below.

Layer 5 — Outputs & Integrations Audit

Score each item 0-2:

Layer 5 Score: ___ / 10

Total OS Stack Score: ___ / 50

Scorecard Interpretation

The OS Build Order

Build exactly in this order. Do not skip.

Phase 1: Foundation (Week 1, ~4 hours)

Goal: Agent is connected to your tools and can receive commands.

Checklist:
□ Install OpenClaw or Claude Desktop (latest version)
□ Connect 3+ MCP servers (GitHub, Notion, Slack minimum)
□ Store all API keys in secrets manager (not .env files)
□ Back up config to git repo
□ Test: Claude can read from and write to each connected tool

Done when: You can ask "list my GitHub issues" and get real data.

Phase 2: Memory Architecture (Week 1-2, ~3 hours)

Goal: Agent remembers who you are, what you're building, and what matters.

Core memory files to create:

SOUL.md — Who is this agent? What's the mission?
MEMORY.md — Long-term decisions, preferences, context
memory/YYYY-MM-DD.md — Daily session notes (append each session)
FOCUS.md — Current #1 priority (updated each session)

SOUL.md template:

# Agent Identity
Name: [Agent name]
Mission: [One sentence — what are we building/achieving?]
Owner: [Your name]
Voice: [Tone: direct/warm/analytical/etc]

## Operating Principles
1. [Core behavior rule]
2. [Core behavior rule]
3. [Core behavior rule]

## KPIs
- [Primary metric with target]
- [Secondary metric with target]

MEMORY.md template:

# Long-Term Memory

## Decisions Made
- [Date] [Decision] — Reason: [why]

## Preferences Learned
- [Preference] — Context: [when this applies]

## Active Projects
- [Project name] — Status: [status] — Next: [action]

## Lessons Learned
- [Lesson] — Source: [what caused this learning]

Done when: You start a session and the agent knows your name, mission, and current priority without you explaining it.

Phase 3: Skill Architecture (Week 2, ~4 hours)

Goal: Agent has 5+ targeted capabilities installed as named skills.

Skill selection decision tree:

What do you do repeatedly that takes > 20 min?
├── Research task → Install a research skill
├── Writing task → Install a writing/content skill
├── Analysis task → Install an analysis skill
├── Ops/integration task → Install an ops skill
└── Strategy task → Install a strategy skill

Skill quality checklist (for each skill you install):

□ Named proprietary framework (not just a prompt)
□ Decision tree or scoring rubric included
□ Structured output format defined
□ Example usage documented
□ Tested at least once before relying on it

Skill catalog file (create at project root):

# Skill Catalog

| Skill Name | Framework | Use Case | Last Used |
|------------|-----------|----------|-----------|
| [name] | [framework] | [when to use] | [date] |

Done when: You can say "use [skill]" and the agent knows exactly what framework to apply.

Phase 4: Agent Routing (Week 2-3, ~3 hours)

Goal: Right model for right task. Parallel when possible.

Model Routing Matrix:

Sub-agent trigger rules:

Spawn a sub-agent when:
□ Task is independent (doesn't need main agent's context)
□ Task takes > 10 minutes
□ Multiple independent tasks exist (run in parallel)
□ Task is risky (isolate it from main session)

Don't spawn a sub-agent when:
□ Task takes < 5 minutes
□ Task needs real-time interaction
□ Task requires continuous context from main session

Done when: You're running parallel sub-agents on independent tasks and using Haiku for simple work automatically.

Phase 5: Output Integration (Week 3, ~3 hours)

Goal: Agent outputs land in the right place automatically.

Integration checklist:

□ Agent can post to Slack (configured + tested)
□ Agent can write to Notion database (configured + tested)
□ Agent can create GitHub issues (configured + tested)
□ Approval gate configured for write operations
□ At least 1 automated loop running

Done when: You get a Slack notification from your agent without asking for it.

Architecture Reference Diagrams

Minimal Viable AI OS (Good)

[User] → [Claude + Memory] → [2-3 MCP tools] → [Slack output]

Standard AI OS (Better)

[User] → [Main Agent + Full Memory Stack]
              ↓
         [Skill Layer: 5+ skills]
              ↓
         [MCP Layer: 4+ tools connected]
              ↓
    [Outputs: Slack + Notion + GitHub]

Full AI OS (Best)

[User / Triggers] → [Main Agent + Full Memory Stack]
                          ↓
                    [Skill Layer: 10+ skills]
                          ↓
              [Sub-agent Routing Layer]
             /            |            \
    [Sub-agent 1]  [Sub-agent 2]  [Sub-agent 3]
    (Research)     (Writing)      (Ops)
             \            |            /
                          ↓
                [MCP Integration Layer]
           (GitHub + Notion + Slack + Linear)
                          ↓
              [Outputs: Auto-routed by type]

Common Anti-Patterns (and fixes)

Example Session

User prompt:

"Audit my current AI setup and tell me what to build next."

Agent response using this skill:

1. Asks user to self-score each layer of the OS Stack Scorecard
2. Calculates total score and identifies weakest layer
3. Generates prioritized build order based on scores
4. Provides specific implementation checklist for the weakest layer
5. Estimates time investment per phase
6. Books follow-up check: "In 1 week, re-score Layer [X]"

Bundle Note

This skill is part of the AI Setup & Productivity Pack ($79 bundle):

• MCP Server Setup Kit ($19)
• Agentic Loop Designer ($29)
• AI OS Blueprint ($39) — *you are here*
• Context Budget Optimizer ($19)
• Non-Technical Agent Quickstart ($9)

Save $36 with the full bundle. Built by @Remy_Claw.