DOCSEARCHbyAlgolia
Submit Docs

AIS-OS

repository·main·Indexed 21 days ago

https://github.com/nateherkai/ais-os

An AI Operating System starter kit designed for Claude Code. It provides a structured framework—the Three Ms (Mindset, Method, Machine) and the Four Cs (Context, Connections, Capabilities, Cadence)—to transform Claude Code into a personalized automation engine. The kit includes interactive skills such as /onboard for setup, /audit for gap reporting, and /level-up for identifying automation artifacts, along with a standardized repository layout for managing business context and decision logs.

Tokens
3.8K
Snippets
2
Records
17
Agent score
76%

What's inside AIS-OS

  1. Explore upcoming specialized frameworks in the 3Ms ecosystem

    main

    The 3Ms (Mindset, Method, Machine) serves as the foundational framework. Future specialized frameworks will be added to the references/ directory to provide deeper guidance on specific technical domains. These include:

    • The Data Retrieval Hierarchy: Guidance on using Filters, SQL, Full Context, or RAG.
    • The Integration Ladder: A hierarchy of reliability covering API, CLI, Browser Automation, and Scraping.
    • The Error Handling Playbook: Strategies for managing system failures.
    • The Model Selection Guide: Criteria for picking the appropriate model for specific tasks.
    • The Context Engineering Framework: Techniques for feeding AI optimal information.
    • The Discovery Playbook: Methods for running discovery with clients or teams.
    • The Security and Permissions Playbook: Managing access control, audit trails, and risk.

  2. Apply the Layer 1 Mindset (How to Think)

    main

    To effectively use AI in your workflow, adopt the following mental models:

    • The Default Shift: Before performing any task manually, ask "How could AI do this?" If it cannot do the whole task, identify how it can assist with the first 30%.
    • The Function Breakdown: Do not attempt to automate entire jobs. Instead, break your role into tiny, discrete functions (e.g., instead of "automating a video," automate "title generation" or "timestamp creation") and automate them one by one.
    • The Curiosity Rule: Avoid "dark code" (automation you don't understand). Treat AI as a mentor: always ask for alternatives, ask why a specific output was chosen, and ensure you can explain the underlying logic of any automation you build.

    Note on the Productivity Dip: Expect a ~20% decrease in output during the first two weeks as you learn new prompting cadences and workflows.

  3. Apply the Governing Principles of the 3Ms Framework

    main

    When designing or operating AI systems within this kit, adhere to these three core principles to ensure stability and progress:

    1. Boring is beautiful: Prioritize predictability over cleverness. Always default to the simplest, most deterministic approach that fulfills the requirement.
    2. Deterministic steps vs. Evolving AI steps: Distinguish between rule-based logic (which is considered 'finished' once implemented) and AI-driven logic (which requires continuous tuning and evolution).
    3. Fail fast, learn faster: Prioritize rapid iteration. Aim to reach your first 10 mistakes quickly to gain real learning through practical failure rather than excessive planning.

  4. Understand the Three Ms operator brain

    main

    The Three Ms framework is a mental model for how to think about AI leverage. It is used during the /level-up skill to move from ideation to implementation.

    • Mindset: Shifting your default thinking toward automation. Key concepts include the Default Shift, Function Breakdown, and the Curiosity Rule (asking "to what extent can AI be leveraged here?").
    • Method: The process of implementation: Find Constraint $\rightarrow$ EAD (Eliminate, Automate, Delegate) $\rightarrow$ Map Process $\rightarrow$ Pick Autonomy Level $\rightarrow$ Tie to KPI.
    • Machine: The technical execution principles: Lego Principle, Validation Chain, Bike Method, Intern Rule, and Kill Switch. The core philosophy is that "workflows beat agents."

  5. Understand the Four Cs architecture

    main

    The Four Cs framework defines the layers of your AI Operating System architecture. You should build these layers in order, as Context is the non-skippable foundation.

    1. Context: The layer that knows your business. A fresh Claude session should be able to answer "what does this business do and who works here?" without browsing.
    2. Connections: The layer that reaches your data. It should be able to answer questions like "what's on my calendar tomorrow?" using live data without manual pasting.
    3. Capabilities: The layer that knows how to do the work. A short phrase should trigger a multi-step workflow that produces a specific artifact.
    4. Cadence: The layer that runs autonomously. The system should be able to respond to inbox briefs or teammate messages even when your laptop is closed.

    Dependency Rule: Do not attempt to automate workflows (Cadence) until you have established working manual processes (Context, Connections, and Capabilities).

  6. Avoid AIS-OS anti-patterns

    main

    To keep the AIOS lean and functional, avoid these common organizational mistakes:

    • Do not dump raw data: Avoid putting raw email or Slack archives into references/. Use interpreted facts only.
    • Avoid deep nesting: Do not build complex folder hierarchies for 'organization theater'. Prefer a flat structure with clear naming.
    • Avoid 'graveyard' folders: Do not add notes/, misc/, tmp/, or inbox/. Use archives/ for old items and specific folders for new items.
    • Do not pre-create empty folders: Only add folders when they are actually needed.
    • Do not duplicate decision logs: Use decisions/log.md exclusively; do not create a parallel decisions.md.
    • Do not fork the operating manual: Maintain one canonical CLAUDE.md at the root. While Sub-OS folders can have their own scoped CLAUDE.md, the root remains the primary authority.

  7. Maintain AIS-OS through regular cadences

    main

    To prevent the AIOS from becoming disorganized, follow these maintenance cadences for specific surfaces:

    • decisions/log.md: Update every time a meaningful decision is made (Note: /level-up Phase 2 captures these automatically).
    • archives/: Perform a quarterly cleanup; move stale projects, deprecated skills, and old intake versions here.
    • references/sops/: Write a new SOP whenever a process is re-run by someone new.
    • connections.md & references/{tool}-api.md: Update both simultaneously whenever a new tool is wired in.
    • CLAUDE.md: Perform a quarterly review; rewrite the persona/priorities section after completing /level-up Q90.

  8. Quick start with AIS-OS

    main

    Follow these steps to set up and begin using the AIS-OS starter kit with Claude Code:

    1. Clone the repository to a local working folder.
    2. Initialize with /onboard: Open the folder in Claude Code and run the /onboard command. Complete the 7-question interview (ensure you paste actual voice samples rather than describing them). This process takes approximately 15 minutes and generates your initial file set and populates CLAUDE.md.
    3. Daily Usage: Use the kit for your real-world tasks. Log decisions using the /decision command or by appending directly to decisions/log.md.
    4. Weekly Maintenance:
      • Day 7: Run /audit to receive a Four-Cs gap report. Identify one gap to address.
      • Day 14: Run /level-up to start the Three Ms interview, which helps identify one automation artifact to build.
      • Week 3+: Continue the weekly /level-up ritual to ship one new artifact per week.
    # 1. Clone the repo
git clone <repo-url>

# 2. Open in Claude Code and run onboarding
claude
/onboard

  9. Apply the Layer 2 Method (How to Decide)

    main

    Use this methodology to determine what to automate and how to structure it:

    1. Identify Constraints

    Ask two questions to find your focus:

    • Bottlenecks: "If 500 new clients showed up tomorrow, what would break first?"
    • Growth: "What would give you 500 more clients tomorrow?"

    2. Use the EAD Framework

    Run every process through this sequence:

    1. Eliminate: Kill processes that add no value or that nobody would notice if they disappeared.
    2. Automate: Apply the 60/30/10 Golden Rule:
      • ~60% fully automated (no human touch).
      • ~30% AI-assisted (AI works, human reviews).
      • ~10% manual (high nuance/risk).
    3. Delegate: If a process cannot fit the 60/30/10 ratio, delegate it to a person.

    3. Map the Process

    Before building, document these five elements for every process:

    • Trigger: What starts the process.
    • Data Sources: Where information originates.
    • Data Transformations: How data changes shape.
    • Decision Points: Where the logic branches.
    • Destination: Where the output is sent.

    4. Select an Autonomy Level

    Default to the lowest level that works to maintain determinism:

    LevelNameDescription
    L0ManualHuman does everything.
    L1SuggestedAI suggests, human decides every step.
    L2DraftedAI drafts, human reviews/edits.
    L3SupervisedAI runs based on rules, human validates.
    L4AutonomousAI handles end-to-end.

    5. Tie to a KPI

    Ensure the automation moves a metric in one of these three buckets:

    1. Get more customers (e.g., lead gen, outreach).
    2. Make each customer worth more (e.g., upselling, retention).
    3. Cut costs (e.g., reducing errors, boosting productivity).

  10. Apply the Layer 3 Machine (How to Build and Operate)

    main

    Follow these principles to build and maintain robust AI systems:

    Building Principles

    • The Lego Principle: Build with the smallest possible steps. One input, one output per block. Start with zero-AI (deterministic) steps first, then layer in AI.
    • The Assembly Line: Avoid generalist models. Use specialized model calls for specific tasks (e.g., one for copywriting, one for classification).
    • The Validation Chain: Do not test end-to-end immediately. Build step 1, validate output, then build step 2 using step 1's output. Repeat.

    Operating Principles

    • The Bike Method (Phased Rollout):
      • Phase 1 (Training wheels): Run manually and watch/correct everything.
      • Phase 2 (Guided): Automation runs but outputs are reviewed/drafted.
      • Phase 3 (Watched): Autonomous runs with human monitoring and anomaly alerts.
      • Phase 4 (Hands-off): Full autonomy.
    • The Intern Rule: Treat AI as a new hire. Give it its own identity (email/accounts), grant read-only access by default, ensure it never impersonates you, and provide a full audit trail with scoped permissions.
    • The Kill Switch: If an automation becomes too expensive to maintain or produces low-quality output, dismantle it. Do not fall for the sunk cost trap.

  11. Determine when to add a new folder

    main

    Before adding a new folder to your AIS-OS, evaluate it against these three criteria. You should only add the folder if you answer YES to at least two of the following:

    1. Is this conceptually new? (Does it not fit into an existing folder?)
    2. Will I touch this 3+ times in the next month? (Is it frequent enough to justify the structure?)
    3. Could /level-up route a future skill into here naturally? (Is it compatible with the AIOS automation patterns?)

    Decision Rule:

    • 2+ Yes answers: Add the folder.
    • 1 or 0 Yes answers: Wait.

  12. Use AIS-OS skills: /onboard, /audit, and /level-up

    main

    The kit provides three primary interactive skills to manage your AI Operating System:

    SkillTypePurposeTiming
    /onboardSetup wizardA one-time 7-question interview that generates your Day-1 file set and populates CLAUDE.md.Immediately after cloning
    /auditRecurring thinking skillA read-only tool that generates a Four-Cs gap report to check if your AIOS is built correctly.Weekly (starting Day 7)
    /level-upRecurring thinking skillAn interview based on the Three Ms framework to identify business leverage and surface one automation artifact to build.Weekly (starting Day 14)

    Note: /audit focuses on form (structure), while /level-up focuses on function (leverage).