Founder Mode OS v2.0

Welcome to insifr OS

Rashad Nazarli's personal AI-powered product development operating system. Think once at the system level. Let AI execute rapidly at the feature level.

Phases

Artifacts

Agents

50+

Skills

Commands & Quick Start

Start the AI Company (Paperclip)

npx paperclipai run
# Dashboard: http://localhost:3100/INS/dashboard

Start the Web Interface

cd insifr-app/ && npm run dev
# UI: http://localhost:3000

Remote Access (Cloudflare Tunnels)

/opt/homebrew/bin/cloudflared tunnel --url http://localhost:3100
/opt/homebrew/bin/cloudflared tunnel --url http://localhost:3000

Use these commands to access your local dashboard securely from any device.

The 8-Phase Lifecycle

Products flow through 8 strictly-gated phases. Code is never written before strategy is locked. Quality gates require CEO approval at each transition.

Phase 0: INITIALIZATION (CEO Agent)
     ↓  Receive brief → ask questions → set mode → delegate

Phase 1: DISCOVERY ──→ Phase 2: STRATEGY ──→ Phase 2.5: CUSTOMER DEV ──→ Phase 3: AUDIENCE
     │                      │                      │                           │
     ▼                      ▼                      ▼                           ▼
  IDEA.md              STRATEGY.md           CUSTOMER_DEV_PLAN.md         PERSONAS.md
  VALIDATION.md        PRD.md                INTERVIEW_GUIDE.md           JOURNEY.md
  MARKET.md            ROADMAP.md            EXPERIMENT_LOG.md
                                             FEEDBACK_DOSSIER.md

             ⛩ GATE: Strategy & Audience Locked (CEO approval)

Phase 4: BRAND & DESIGN ──→ Phase 5: UX IMPLEMENTATION
             ⛩ GATE: UX Locked

Phase 6: ENGINEERING ──→ Phase 7: LAUNCH
             ⛩ GATE: Engineering Blueprint Locked

Phase 8: REVENUE & ITERATION (continuous loop)
  TELEMETRY → GROWTH_OPS → EXPERIMENTATION → ITERATION_LOG → RETROSPECTIVE

Project Modes

Mode	Artifacts	Use Case
`--full`	All 43	New product, 0→1
`--technical`	Engineering only	Consulting / tech-only engagement
`--maintenance`	Phase 8 only	Live product ops (Avena, Celentano)

The 43 Core Artifacts

Phase	Key Artifacts	Owner
1–3: Discovery & Strategy	Idea, Market Research, PRD, Roadmap, Personas, Journey	PM
2.5: Customer Dev New	Customer Dev Plan, Interview Guide, Experiment Log, Feedback Dossier	PM
4–5: Brand & UX	Brand Guidelines, Design Tokens, Design System, Components, Layouts, Wireframes, UI Spec	Designer
6: Engineering	Architecture, Database Schema, API Spec, Infrastructure	Architect
7: Launch	Workflows, Feature Execution, UX Audit, Architecture Review, Growth Strategy, Pitch Deck	Engineer / PM
8: Revenue & Iteration	Telemetry Model, Growth Ops, Experimentation Backlog, Iteration Log, Runbook, Project Retrospective	CEO / SRE

Agent Team & Roles

👔 CEO Agent

Rashad's digital twin. Receives briefs, coordinates the team, holds quality gates, runs retrospectives. Active in all phases.

📊 PM Agent

Owns Strategy, Discovery, Customer Development, Growth Ops & Telemetry. Phases 1–3, 8.

🎨 Designer Agent

Owns Brand & UX. Translates strategy into Design Systems, UI Specs, and Wireframes. Phases 4–5.

📐 Architect Agent

Owns Engineering blueprints and SRE Runbooks. Selects the stack and defines APIs. Phases 6, 8.

💻 Engineer Agent

Writes the code, launches the product, maintains the iteration log. Phases 7, 8.

🛡️ Auditor Agent

Continuous governance, red-teaming, fix-first code reviews, GDPR/AAOIFI compliance. All phases.

Routines & Quality Gates

The OS enforces discipline through 30 markdown routines. Key routines:

Routine	Purpose
`phase-gate.md`	Mandatory checkpoints between phases — AI must refuse to proceed if artifacts are missing
`new-feature.md`	Full feature implementation with verification-before-completion and git worktree support
`debug.md`	4-phase systematic debugging: Isolate → Reproduce → Trace → Fix
`review.md`	Security & architecture audit with OWASP Top 10 and verification gate
`prd-to-tasks.md`	Converts PRD to granular 2–5 min tasks with exact file paths and verification steps

Skills Library (50+)

Agent skills are structured markdown instructions that define specific capabilities. All skills follow the Minimum Skill Quality Spec.

📈 Product Analytics Analyst

Ingests telemetry → generates insights → proposes roadmap updates. Closes the data→decisions loop.

🗣️ User Feedback Synthesizer

Processes interviews, NPS, support tickets into structured insights linked to Personas and Journey maps.

🧪 AI Eval Lab

Meta-skill: evaluates other skills and agent outputs using LLM-as-judge scoring (1–5 rubric).

🔌 MCP Integration Builder

Auto-scaffolds MCP server configs for PostgreSQL, Firebase, Sentry, GitHub connections.

Systematic Debugging

The OS enforces a rigorous 4-phase root cause process. No more "shotgun debugging."

1: Isolate

Narrow the scope. Which component, service, or layer is failing? Strip away unrelated systems.

2: Reproduce

Create exact conditions to trigger the bug 100% of the time. Write a failing test or script.

3: Trace

Work backwards from the failure point. Inspect state at each step. Find the divergence.

4: Fix

Apply the minimal atomic fix. Run the reproduction case. Confirm in context. Commit.

End-to-End Walkthrough

How an idea goes from conception to production using the Founder Mode OS.

1. The Briefing (Phase 0)

Agent: CEO | Time: Day 1

Rashad provides a rough brief to the CEO Agent: "I want to build a tool that helps consultants track time and bill clients securely." The CEO Agent asks clarifying questions and creates the IDEA.md artifact.

2. Strategy & Validation (Phases 1-3)

Agent: PM | Time: Day 1-3

The PM Agent takes over, generating STRATEGY.md, PRD.md, and running Phase 2.5 (Customer Development). It outlines an INTERVIEW_GUIDE.md for Rashad to use in user interviews. Once interviews are done, it generates a FEEDBACK_DOSSIER.md.

⛩ Quality Gate 1: The CEO Agent reviews the artifacts. Strategy & Audience are locked. Proceed.

3. Brand & UX (Phases 4-5)

Agent: Designer | Time: Day 4-5

The Designer Agent reads the PRD and Personas, then generates a DESIGN_SYSTEM.md and writes the initial CSS tokens. It creates structural wireframes for the dashboard.

⛩ Quality Gate 2: Rashad approves the visual direction. UX is locked.

4. Engineering Blueprint (Phase 6)

Agent: Architect | Time: Day 6

The Architect Agent decides on Next.js + PostgreSQL + Tailwind. It generates ARCHITECTURE.md and a detailed API_SPEC.md. The Auditor agent runs a preliminary security check using the /cso skill.

5. Execution & Launch (Phase 7)

Agent: Engineer + Auditor | Time: Day 7-10

The Engineer Agent converts the PRD into tasks using prd-to-tasks.md. Tasks are strictly 2-5 minutes long. Multiple git worktrees are spun up for parallel execution. The /qa atomic loop tests every commit. Once built, the app is deployed.

6. Revenue & Iteration (Phase 8)

Agent: CEO + PM | Time: Ongoing

The app is live. The PM Agent's product-analytics-analyst skill connects via MCP to PostHog, reads live telemetry, and adds new feature requests to the EXPERIMENTATION_BACKLOG.md. The cycle repeats.

MCP Integration

The Model Context Protocol (MCP) connects the OS to live external services, enabling agents to query databases, fetch error traces, and manage repos without leaving the IDE.

Service	Use Case
PostgreSQL	Query Celentano DB during bug reproduction
Firebase	Query Avena Firestore collections
Sentry	Fetch live stack traces for debugging
GitHub	Automate PR creation and issue management

Episodic Memory

A lightweight SQLite-backed system that records agent decisions, tool calls, errors, and outputs per project. Enables cross-session pattern detection and breaks recursive error loops.

Architecture

episodes table — logs every agent action
error_patterns table — tracks recurring errors
DB Path: ~/.gemini/antigravity/memory/<id>.db

Integration Points

Session Start: Surface known error patterns
Error Handling: Check resolutions before debugging
Retrospective: Auto-build timeline from logs

Advanced Patterns

Parallel-Project Isolation

When running multiple projects simultaneously (e.g. Avena and Celentano):

Shared (OS-level): FOUNDER_MODE.md, routines, skills, prompts.
Isolated (Per-project): All 43 artifacts, progress JSONs, codebases.
Use git worktrees for simultaneous code work in separate branches.

Granularity Standard

Every task must be 2–5 minutes of execution, specify exact file paths, include complete code, and end with a verification command. No vague "build the dashboard" tasks.