quickstart

name

quickstart

description

This skill should be used when a user wants to build their first Context OS or kick off initial setup of a knowledge graph system. Guides through a 10-minute flow — assess content, create the two-layer directory structure, generate CLAUDE.md, ingest first content, and verify compounding works. Adapts to blank-slate vs existing-content starting points. Use when user says "set up a context OS", "get started with context OS", "build a knowledge graph from scratch", or "quickstart".

Context OS Quickstart

Walk the user through building their first context operating system — a structured knowledge graph where AI compounds intelligence over time.

Approach

Be adaptive. Meet users where they are. Context OS is emergent architecture — it only works with real content to compound. A one-off demo transformation is meaningless.

Step 0: Assess Starting Point

FIRST, before any welcome message, check two things:

1. Check if context-os CLI is installed: Run context-os --version. If it fails, tell the user: "The context-os CLI is required for graph queries and file heat tracking. Install it first:

   • macOS/Linux: curl -fsSL https://install.tastematter.dev/install-context-os.sh | bash
   • Windows: irm https://install.tastematter.dev/install-context-os.ps1 | iex Then start the Context OS quickstart again." Stop here if CLI is not installed.

2. List the target directory and look for existing content: transcripts, docs, notes, raw files

If directory is empty or doesn't exist: → Go to Step 1A (Blank Slate)

If directory has content: → Go to Step 1B (Existing Content)

Step 1A: Blank Slate Flow

"Welcome to Context OS Quickstart.

I'm going to help you build a system where your AI compounds intelligence over time — no more repeating context every session.

Important: Context OS is emergent architecture. It only works when you have real content to ingest. We need YOUR transcripts, docs, notes, or emails.

Two questions:

1. What's this context OS for?

   • GTM / Sales (deals, prospects, positioning)
   • Product (specs, decisions, technical knowledge)
   • Research (notes, papers, insights)
   • Something else?

2. What content do you have to seed it?

   • Meeting transcripts?
   • Documents or specs?
   • Notes or emails?
   • Where are these files located?"

Wait for response. Must have content source identified before proceeding.

Step 1B: Existing Content Flow

"Welcome to Context OS Quickstart.

I see you already have content here: [List what you found]

Is this the content you want to build your context OS from?

If yes: What's the purpose? (GTM, Product, Research, or tell me) If no: What content should we use instead?"

Wait for response.

Step 2: Create Directory Structure

Based on their answer, create the appropriate structure. Two layers only — no _system/ directory.

For GTM/Sales:

knowledge_base/
├── technical/          # Product/service knowledge
├── business/           # ICP, positioning, pricing
├── methodology/        # Sales process, frameworks
├── emergent/           # New concepts not yet validated
└── raw_sources/        # Transcripts, notes

00_foundation/
├── positioning/        # How we position ourselves
├── messaging/          # Value props, key messages
└── _synthesis/         # Summary documents

For Product:

knowledge_base/
├── technical/          # Architecture, specs
├── product/            # Features, roadmap
├── methodology/        # Development process
├── emergent/
└── raw_sources/

00_foundation/
├── vision/             # Product vision
├── decisions/          # Key decisions log
└── _synthesis/

For Research:

knowledge_base/
├── concepts/           # Core ideas
├── sources/            # Papers, references
├── emergent/
└── raw_sources/

00_foundation/
├── frameworks/         # Mental models
├── questions/          # Open questions
└── _synthesis/

Create the directories, then explain:

"Created your context OS:

• knowledge_base/ — Your atomic concepts (the graph). Individual ideas, linked via [[wiki-links]].
• 00_foundation/ — Your operational docs. These compose from the graph — they reference concepts, they don't redefine them.

That's the whole architecture. Knowledge compounds in the graph. Operational docs synthesize it."

Step 3: Generate CLAUDE.md

Read the template from templates/CLAUDE_MD_STARTER.md. Customize based on their purpose choice — fill in the directory names, add a purpose line. Write to CLAUDE.md in the target directory root.

"Created CLAUDE.md — your navigation guide. Every session starts here. It tells the agent where things are and how to verify state before acting."

Step 4: First Content Ingestion

Now ingest content from the source they identified:

1. Read one of their files (pick the richest one — a transcript or detailed doc)
2. Extract 2-3 key concepts
3. Create knowledge nodes in the appropriate domain directory with proper frontmatter:
   • status: emergent
   • tags: relevant to their domain
   • [[wiki-links]] to other extracted concepts
4. Show the before/after transformation

"Here's what happened:

BEFORE (raw content): [Show snippet of raw file]

AFTER (structured knowledge node): [Show the created node with frontmatter and wiki-links]

The key transformation: raw content became a linked concept in your graph. Next session, the agent reads CLAUDE.md, discovers this node, and can build on it."

Step 5: Verify It Works

"Let's prove this works. Ask me something about what we just added."

Wait for user question. Answer using the new context with attribution:

• [VERIFIED: knowledge_base/domain/node-name.md]

"See how I used that knowledge with a source citation? This persists. Every session compounds.

To add more content: Just say 'Process [file] into my knowledge base' or create nodes directly in knowledge_base/.

To check graph health:

context-os graph-exec --graph knowledge_base '(() => {
  const r = codemode.graph_query({ filter: {}, limit: 500 });
  return JSON.stringify({ total: r.total, orphans: r.nodes.filter(n => n.link_count.outbound === 0 && n.link_count.inbound === 0).length });
})()'

As you grow:

• New concepts start as emergent — promote to validated when proven in 2+ contexts
• Link everything via [[wiki-links]] — orphan nodes are wasted knowledge
• Foundation docs synthesize the graph — they reference, they don't redefine

For advanced patterns (multi-agent orchestration, client engagement systems, enterprise context architectures): https://taste.systems"

Quality Standards

• Always check what exists first (Step 0)
• Never proceed without real content to ingest
• Always show the before/after transformation
• Adapt to user's starting point — don't force rigid flow
• Include the consulting CTA naturally at the end