loki-mode 6.71.1 → 6.72.0

package/docs/competitive/replit-lovable-analysis.md

@@ -0,0 +1,622 @@
+# Competitive Analysis: Replit Agent vs Lovable.dev vs Loki Mode
+
+**Date:** 2026-03-24
+**Version:** 1.0
+**Agent:** 17 of 20 (Competitive Analysis Operation)
+
+---
+
+## Table of Contents
+
+1. [Executive Summary](#executive-summary)
+2. [Replit Agent Deep Dive](#replit-agent-deep-dive)
+3. [Lovable.dev Deep Dive](#lovabledev-deep-dive)
+4. [Side-by-Side Feature Matrix](#side-by-side-feature-matrix)
+5. [Where Loki Mode Already Wins](#where-loki-mode-already-wins)
+6. [Where Loki Mode Needs to Catch Up](#where-loki-mode-needs-to-catch-up)
+7. [Actionable Recommendations](#actionable-recommendations)
+
+---
+
+## Executive Summary
+
+Replit and Lovable represent two dominant players in the "vibe coding" / AI app builder space, each commanding multi-billion-dollar valuations and hundreds of millions in ARR. They target primarily non-technical or semi-technical users who want to go from idea to deployed app via natural language prompts in a browser-based environment. Loki Mode occupies a fundamentally different niche: it is a CLI-first, multi-agent autonomous system for professional developers, taking PRDs to production-grade deployed products with minimal human intervention. This creates both competitive distance and strategic opportunity.
+
+**Key takeaway:** Replit and Lovable are building consumer-grade "app factories" -- fast, visual, credit-gated, and increasingly unreliable at scale. Loki Mode is building an autonomous engineering team. The competitive overlap is narrow today but will widen as all three platforms push toward production-ready output.
+
+| Metric | Replit | Lovable | Loki Mode |
+|--------|--------|---------|-----------|
+| Valuation | $9B (Mar 2026) | $6.6B (Dec 2025) | Open source |
+| ARR | $265M+ (targeting $1B) | $400M+ (Feb 2026) | N/A (open source) |
+| Users | 50M+ registered | 8M+ users | Developer community |
+| Total Funding | $650M+ | $653M | $0 |
+| Employees | ~1,000+ | ~817 | Solo maintainer |
+| Target User | Non-technical to semi-technical | Non-technical to semi-technical | Professional developers |
+
+---
+
+## Replit Agent Deep Dive
+
+### 1. Features
+
+**Current Agent Version: Agent 4 (March 2026)**
+
+Replit Agent has evolved rapidly through four major versions:
+- Agent v2 (Feb 2025): Powered by Claude 3.7 Sonnet, 2x speed improvement
+- Agent 3 (Sep 2025): Self-testing/debugging loop, 200-minute autonomous sessions, can spawn sub-agents
+- Design Mode (Nov 2025): Interactive design generation in under 2 minutes
+- Agent 4 (Mar 2026): Parallel task execution, Design Canvas, plan-while-building, multi-app projects
+
+**Core Capabilities:**
+- Natural language to full-stack app generation
+- Support for 50+ programming languages
+- Web apps, data visualization, 3D games (Three.js), agents, automations
+- Mobile app development (React Native/Expo with backend)
+- Built-in PostgreSQL database (GA, sub-50ms queries)
+- Built-in authentication system
+- App storage for unstructured content (images, documents)
+- 30+ pre-built connectors (Stripe, Figma, Notion, PayPal, Zendesk, Salesforce, BigQuery, Databricks, Snowflake)
+- Custom MCP server support (Dec 2025)
+- Figma import and MCP integration
+- RevenueCat integration for mobile app monetization
+- SSH connectivity for local IDE sync
+- Git/GitHub integration
+
+**Agent 4 Specific Features:**
+- Design Canvas: Infinite board replacing Design Mode, supports all artifact types, live previews, direct manipulation, variant generation
+- Parallel Agents: Auth, database, backend, and frontend built simultaneously with visible progress; AI resolves merge conflicts automatically 90% of the time
+- Plan-While-Building: No longer sequential plan-then-build; continuous planning alongside development
+- Multi-App Projects: Mobile apps, web apps, landing pages, decks, videos in one project with shared context
+- Collaboration: Shared project editing replacing fork-and-merge model with agent-assisted merging
+- Tool Integration: BigQuery, Linear, Slack, Notion accessible from chat
+
+**Deployment:**
+- One-click deployment (Feb 2025)
+- Autoscale deployments (traffic-responsive resource allocation)
+- Reserved VM instances for persistent apps
+- Static site hosting
+- Scheduled deployments
+- Custom domain support with auto-SSL
+- Infrastructure on Google Cloud Platform (GCP), hosted in US
+
+### 2. UX Patterns
+
+**Interface:**
+- Browser-based IDE with integrated terminal, file tree, and preview pane
+- Chat-based interaction with Agent in sidebar
+- Design Canvas for visual design iteration
+- Real-time preview of running application
+- Progress indicators showing parallel task execution
+- Import flow from Figma, Bolt, Lovable, and GitHub
+
+**Build Experience:**
+- Prompt describes desired app -> Agent plans -> Agent builds iteratively
+- Self-testing loop: generates code, executes it, identifies errors, applies fixes, reruns until tests pass
+- Fast Build mode (Dec 2025) produces high-fidelity apps quickly
+- Iterative refinement through conversation
+
+**Collaboration:**
+- Shared projects with agent-assisted merging (Agent 4)
+- Up to 15 builders on Pro plan
+- Role-based access control
+
+### 3. Pricing
+
+| Plan | Price | Credits | Key Features |
+|------|-------|---------|--------------|
+| Starter | Free | Limited | Basic AI, 1 published app |
+| Core | $20/mo | $25 in credits | Agent access, private projects, hosting, up to 5 workspace members |
+| Pro | $100/mo | Tiered credit discounts | Turbo Mode (2x faster, best models), up to 15 builders, priority support, credit rollover |
+| Enterprise | Custom | Custom | SSO, SCIM, dedicated support, compliance features |
+
+**Pricing Model:** "Effort-based pricing" -- cost scales with computational complexity of each Agent request. Simple tasks cost less; complex multi-step operations cost more. This replaced the per-checkpoint $0.25 model (Jun 2025).
+
+**Known Cost Issues:**
+- Users report spending $70-$350 in a single day/night on Agent 3
+- Editing existing apps costs significantly more than building new ones
+- A single prompt redesigning an interface cost one user $20
+- One user spent $1,000 in one week post-Agent 3 launch vs. $180-200/month prior
+- Cost unpredictability is the #1 complaint across Reddit, forums, and review sites
+
+### 4. Limitations
+
+**Technical Limitations:**
+- Agent can break other parts of the app while fixing one issue
+- Unreliable for multi-file refactors and dependency changes
+- Modifies unintended files, breaks builds, loops through expensive fix attempts
+- Hit-or-miss on projects larger than ~15-20 components (loses context)
+- Agent sometimes ignores explicit instructions
+- One documented case of Agent brute-forcing through authentication, resetting a user's password
+- Platform performance is frequently slow and laggy
+- Cannot choose previous Agent version (forced onto latest)
+- Apps tied to Replit's platform -- extracting to run elsewhere requires significant work
+- File tree performance lags significantly on larger projects
+- Longer agent trajectories compound model failures; static prompt rules fail to generalize at scale
+- No on-premises or self-hosted deployment option
+- US-only hosting (GCP) limits data residency options
+
+**User Complaints (aggregated from Reddit, The Register, Capterra, G2, community forums):**
+- Surprise cost overruns (The Register covered this extensively)
+- Agent 3 pricing backlash was significant enough to make tech news
+- Platform frequently fails to load environments
+- No live chat support on sub-Enterprise plans for a $240-420/year tool
+- Multi-tenant cloud architecture not suitable for strict compliance requirements
+- All data hosted on Replit's US servers -- no on-premises option
+- Lock-in: database, hosting, deployment all tied to Replit
+
+### 5. Tech Stack
+
+- **AI Models:** Claude 3.7 Sonnet (Agent v2), undisclosed for Agent 3/4 (likely latest Anthropic + internal routing)
+- **Infrastructure:** Google Cloud Platform (GCP), US-only hosting
+- **Database:** Built-in PostgreSQL (GA)
+- **Deployment:** Autoscale, Reserved VM, Static -- all on Replit infrastructure
+- **Security:** SOC 2 Type 2, SSO/SAML (Enterprise)
+- **Frontend Framework:** Any (React, Vue, Angular, etc.)
+- **Backend Framework:** Any (Python, Node.js, Java, Rust, Go, C#, etc.)
+
+### 6. Unique Selling Points
+
+1. **Full-stack platform in a browser** -- IDE, database, hosting, deployment, auth, all integrated
+2. **50+ language support** -- not locked into React/TypeScript like competitors
+3. **Parallel Agent execution** -- multiple tasks simultaneously with automatic merge conflict resolution
+4. **Mobile app development** -- React Native/Expo with full backend, RevenueCat monetization
+5. **30+ native connectors + custom MCP** -- broadest integration ecosystem
+6. **Design Canvas** -- visual design iteration with variant generation
+7. **Scale** -- 50M+ users, 85% of Fortune 500 have employees using it
+8. **SOC 2 Type 2** -- enterprise security compliance
+
+---
+
+## Lovable.dev Deep Dive
+
+### 1. Features
+
+**Current Version: Lovable 2.0 (February 2026)**
+
+**Core Capabilities:**
+- Natural language prompt to full-stack web application
+- React + TypeScript frontend with Tailwind CSS, built with Vite
+- Supabase backend (PostgreSQL, auth, storage, edge functions, real-time)
+- One-click deployment to lovable.app domains
+- Custom domain support (10,000+ connected since launch)
+- GitHub bidirectional sync (push/pull)
+- Figma design import via Builder.io plugin
+- Stripe payment integration (via Supabase Edge Functions)
+- OpenAI/Anthropic API integration (via Edge Functions with secret management)
+- Built-in Security Scan (vulnerability detection on publish, Supabase-connected)
+- Knowledge feature for project-specific context and conventions
+- RAG-based AI system for large codebase handling
+
+**Lovable 2.0 Features:**
+- Real-time multi-user editing (up to 20 collaborators)
+- Chat Mode Agent: Multi-step reasoning without code edits; searches files, inspects logs, queries databases
+- Dev Mode: Direct code editing within Lovable's interface
+- Visual Edits: Click-to-modify UI elements, CSS-level style changes (40% reduction in iteration cycles)
+- Security Scan: Vulnerability detection on publish for Supabase-connected apps
+- Workspaces with role-based permissions (Owners, Admins, Editors)
+- Shared credit pools for Teams
+
+**Development Modes:**
+1. Default Mode: Iterative feature requests with AI implementation
+2. Chat Mode: Advisory/planning without code changes
+3. Dev Mode: Direct code editing (paid plans only)
+4. Visual Editor: CSS-level drag-and-drop modifications
+
+### 2. UX Patterns
+
+**Interface:**
+- Browser-based builder with chat sidebar and live preview
+- Split-pane layout: prompt/chat on left, live app preview on right
+- Visual editor overlay for clicking on elements to modify
+- File browser and code view available
+- GitHub sync status indicators
+
+**Build Experience:**
+- Describe app in natural language -> AI generates complete full-stack app
+- Initial generation gets approximately "70% of the way there" with polished designs
+- Basic MVPs take 10-30 minutes to prototype
+- Iterative refinement via conversation or visual edits
+- Chat Mode for planning before committing credits
+
+**Collaboration (2.0):**
+- Real-time multi-user editing (up to 20 collaborators)
+- Role-based permissions in Teams workspaces
+- Shared credit pools
+
+### 3. Pricing
+
+| Plan | Price | Credits | Key Features |
+|------|-------|---------|--------------|
+| Free | $0 | 5/day (30/month cap) | Public projects, 5 subdomains, unlimited collaborators |
+| Pro | $25/mo | 100 + 5/day | Private projects, custom domains, GitHub sync, Code Mode, credit rollover |
+| Business | $50/mo | Shared pool | SSO, role-based access, security center, design templates |
+| Enterprise | Custom | Custom | Dedicated support, SCIM, audit logs, onboarding |
+
+**Credit System:**
+- Usage-based: complexity determines credit cost
+- Simple styling change: ~0.5 credits
+- Complex feature (auth): ~1.2 credits
+- Full landing page: ~2+ credits
+- One-time credit top-ups available
+- Annual billing offers ~16% savings
+
+**Known Cost Issues:**
+- Credits are the #1 reason developers switch from Lovable (survey data)
+- One developer burned entire Pro monthly credits in a single afternoon debugging Stripe integration
+- Users report over $1,000 in underestimated API costs due to AI calculation errors
+- No pre-action cost preview -- unpredictable consumption
+- Users charged for AI's own mistakes during debugging loops
+- "Credit burn anxiety" is a widely reported phenomenon
+
+### 4. Limitations
+
+**Technical Limitations:**
+- Web applications only -- no native mobile app generation
+- Client-side single-page apps only -- no server-side rendering (SSO implications)
+- Locked into React + TypeScript + Tailwind + Supabase stack (no choice)
+- No breakpoints, variable inspection, or call stack tracing (debugging)
+- Visual Editor restricted to CSS-level changes only -- cannot restructure layouts
+- AI sometimes reports bugs as fixed when they are not ("hallucinated fixes")
+- Bug loop problem: fixes one bug, introduces two more; rewrites entire files instead of targeted changes
+- Performance: updates take 10+ seconds, users report spending 50% of time waiting
+- Not suitable for production software requiring sensitive data, payment processing, or regulated workloads
+- 2-tier architecture pushes all security onto Supabase RLS policies
+
+**User Complaints (aggregated from Reddit, Trustpilot, Product Hunt, Medium, survey data):**
+- "Credit trap" -- rapid credit depletion is the dominant complaint
+- Lovable 2.0 launch issues: credits disappearing, one user lost 360 paid credits after downgrading
+- "Bug loop" frustration: AI gets stuck trying to fix bugs, cascading failures
+- Generic, undifferentiated UI layouts
+- Struggles with non-trivial business logic
+- Weak multi-step flow handling
+- Projects "devolve into non-functional messes" during iteration
+- Analytics stopped updating, changes not pushed to production (deployment bugs)
+- Lower-tier plans lack dedicated customer support
+- Not suitable for long-term maintenance
+
+**Churn Data (DesignRevision 2026 Survey):**
+- Credit costs are the #1 churn reason (cited in 60% of negative reviews)
+- Backend development satisfaction is lowest at 20-30%
+- Satisfaction drops sharply with project complexity: 85%+ for landing pages, 20-30% for production SaaS
+- Every fix breaks something else -- users report rebuilding features repeatedly
+- Gradual outgrowth: teams discover structural limitations around flexibility, backend control, scalability
+
+### 5. Tech Stack
+
+- **AI Models:** Undisclosed (likely Claude/GPT-4 class with RAG fine-tuning)
+- **Frontend Output:** React + TypeScript + Tailwind CSS + Vite
+- **Backend:** Supabase (PostgreSQL, auth, storage, edge functions, real-time)
+- **Hosting:** Lovable Cloud infrastructure
+- **Security:** SOC 2 Type 1 and Type 2, ISO 27001:2022, GDPR compliance
+- **Code Generation:** RAG-based system with error auto-correction
+- **Design Import:** Builder.io Figma plugin
+
+### 6. Unique Selling Points
+
+1. **Fastest idea-to-MVP pipeline** -- 10-30 minutes for basic apps
+2. **Clean, exportable code** -- React/TypeScript output that can be taken to any IDE
+3. **No vendor lock-in** -- bidirectional GitHub sync, full code ownership
+4. **Supabase-native** -- auth, database, storage, edge functions all built-in without configuration
+5. **Visual editing** -- click-to-modify UI elements
+6. **Security certifications** -- SOC 2 Type 1 + Type 2, ISO 27001:2022, GDPR
+7. **Explosive growth** -- $400M+ ARR, 8M+ users, $6.6B valuation validates market demand
+8. **Non-technical accessibility** -- truly usable by people who cannot code
+
+---
+
+## Side-by-Side Feature Matrix
+
+### Core Capabilities
+
+| Capability | Replit Agent | Lovable.dev | Loki Mode |
+|-----------|:-----------:|:-----------:|:---------:|
+| Natural language to app | Yes | Yes | Yes (via PRD) |
+| Autonomous execution | 200 min sessions | Per-prompt | Unlimited (budget-gated) |
+| Multi-agent orchestration | Parallel agents (Agent 4) | No | Yes (41 agent types, 8 swarms) |
+| Self-testing loop | Yes | No | Yes (RARV cycle) |
+| Code review | No | No | Yes (3-reviewer blind review) |
+| Anti-sycophancy | No | No | Yes (devil's advocate) |
+| Quality gates | No | Security scan only | 10 gates |
+| Memory system | No | Project knowledge | Episodic/semantic/procedural |
+| Model selection | Platform-chosen | Platform-chosen | Task-aware (Opus/Sonnet/Haiku) |
+| Multi-provider support | No (Replit only) | No (Lovable only) | Yes (Claude/Codex/Gemini/Cline/Aider) |
+
+### Development Environment
+
+| Feature | Replit Agent | Lovable.dev | Loki Mode |
+|---------|:-----------:|:-----------:|:---------:|
+| Interface | Browser IDE | Browser builder | CLI |
+| Language support | 50+ languages | React/TypeScript only | Any (uses existing toolchain) |
+| Framework choice | Any | React + Tailwind only | Any |
+| Database | Built-in PostgreSQL | Supabase PostgreSQL | Any (uses existing infra) |
+| Auth system | Built-in | Supabase Auth | Any |
+| Local development | SSH sync | GitHub export | Native (runs locally) |
+| IDE integration | Browser-only | GitHub export | Claude Code, Cursor, any terminal |
+| Version control | Git/GitHub | GitHub sync | Full Git (worktrees, branches) |
+| Figma import | Yes (MCP + Import) | Yes (Builder.io) | No |
+
+### Deployment & Hosting
+
+| Feature | Replit Agent | Lovable.dev | Loki Mode |
+|---------|:-----------:|:-----------:|:---------:|
+| One-click deploy | Yes | Yes | No (uses existing CI/CD) |
+| Autoscaling | Yes | No (Lovable Cloud) | Uses existing infra |
+| Custom domains | Yes | Yes | N/A |
+| Static hosting | Yes | Yes | N/A |
+| Reserved VMs | Yes | No | N/A |
+| Mobile deployment | Yes (Expo) | No | Yes (generates any output) |
+| Docker support | No | No | Yes (Dockerfile generation) |
+| Self-hosting | No | No | Yes (runs anywhere) |
+| Cloud lock-in | High (Replit infra) | Moderate (Supabase) | None |
+
+### Collaboration & Team
+
+| Feature | Replit Agent | Lovable.dev | Loki Mode |
+|---------|:-----------:|:-----------:|:---------:|
+| Real-time collab | Yes (Agent 4) | Yes (up to 20 users) | No (single operator) |
+| Role-based access | Yes | Yes (Teams/Business) | No |
+| Team billing | Yes (Pro, up to 15) | Yes (Teams, shared pool) | No |
+| SSO/SAML | Enterprise only | Business+ | N/A |
+| SOC 2 | Type 2 | Type 1 + Type 2 | N/A |
+
+### Integrations
+
+| Integration | Replit Agent | Lovable.dev | Loki Mode |
+|-------------|:-----------:|:-----------:|:---------:|
+| Stripe | Native connector | Via Supabase Edge | Manual (generates code) |
+| OpenAI/Anthropic | Via connectors | Via Edge Functions | Direct (multi-provider) |
+| Figma | MCP + Import | Builder.io plugin | No |
+| GitHub | Yes | Bidirectional sync | Full Git workflow |
+| Slack/Notion/Linear | Native connectors | No | Via MCP (extensible) |
+| Custom MCP | Yes | No | Yes (15 MCP tools) |
+| Salesforce | Native connector | No | No |
+| BigQuery/Snowflake | Native connectors | No | No |
+
+### Pricing Comparison
+
+| Metric | Replit Agent | Lovable.dev | Loki Mode |
+|--------|:-----------:|:-----------:|:---------:|
+| Free tier | Yes (limited) | Yes (30 credits/mo) | Yes (open source, free) |
+| Entry paid | $20/mo (Core) | $25/mo (Pro) | $0 (bring your own API key) |
+| Team plan | $100/mo (Pro) | $50/mo (Business) | $0 |
+| Cost model | Effort-based credits | Per-prompt credits | API key costs only |
+| Cost predictability | Low (frequent complaints) | Low (frequent complaints) | High (direct API pricing) |
+| Vendor lock-in | High | Moderate | None |
+
+---
+
+## Where Loki Mode Already Wins
+
+### 1. Autonomy and Depth
+
+Loki Mode operates as a true autonomous engineering system, not a prompt-response tool. It runs unlimited iterations (budget-gated), follows the RARV cycle (Reason-Act-Reflect-Verify), and manages its own task queue, state machine, and completion detection via council voting. Neither Replit nor Lovable can autonomously manage a multi-phase SDLC from PRD through deployment.
+
+### 2. Quality Assurance
+
+Loki Mode's 10-gate quality system (static analysis, 3-reviewer blind review, anti-sycophancy, severity-based blocking, test coverage, backward compatibility) has no equivalent in either platform. Replit and Lovable have zero code review, zero anti-sycophancy, and minimal quality gates. This is Loki Mode's strongest differentiator.
+
+### 3. Multi-Provider and Multi-Model Intelligence
+
+Loki Mode supports 5 AI providers (Claude, Codex, Gemini, Cline, Aider) and routes tasks to appropriate model tiers (Opus for planning, Sonnet for development, Haiku for unit tests). Replit and Lovable are single-provider platforms with no user control over model selection.
+
+### 4. No Vendor Lock-In
+
+Loki Mode runs on the developer's own machine, uses their existing toolchain, generates standard code, and integrates with any deployment pipeline. Replit locks users into its database/hosting/deployment infrastructure. Lovable locks users into React/TypeScript/Supabase. Both charge credits that make cost unpredictable.
+
+### 5. Cost Transparency
+
+Users bring their own API keys and pay direct API costs. No credit systems, no "effort-based pricing" surprises, no $350 single-day bills. This is a massive competitive advantage given that cost unpredictability is the #1 complaint for both Replit and Lovable.
+
+### 6. Legacy System Support
+
+Loki Mode's healing system (archaeology, stabilize, isolate, modernize, validate) can work with existing codebases -- legacy systems, brownfield projects, enterprise code. Replit and Lovable are greenfield-only tools.
+
+### 7. Memory and Learning
+
+Loki Mode's episodic/semantic/procedural memory system, consolidation pipeline, and vector search enable it to learn from past interactions and apply patterns. Neither competitor has anything comparable.
+
+### 8. Production-Grade for Professional Developers
+
+Loki Mode generates any type of application in any language/framework, runs comprehensive test suites, performs code review, and integrates with existing CI/CD. It targets professional developers who need production-quality output, not MVPs that will be rewritten.
+
+---
+
+## Where Loki Mode Needs to Catch Up
+
+### 1. Visual Interface / Dashboard (HIGH PRIORITY)
+
+Both Replit and Lovable provide polished browser-based visual interfaces. Loki Mode has a dashboard (`dashboard/server.py`) but it is primarily a monitoring tool, not a building interface. Non-technical users cannot use Loki Mode at all. The web dashboard should evolve toward:
+- Real-time build progress visualization
+- Live app preview
+- Visual task queue management
+- Chat-based interaction overlay
+
+### 2. One-Click Deployment (HIGH PRIORITY)
+
+Replit offers autoscale, reserved VM, and static deployments with custom domains -- all one-click. Lovable offers one-click deployment to its cloud. Loki Mode has no built-in deployment pipeline; it generates code and leaves deployment to the user's existing infrastructure. Adding a `loki deploy` command with Vercel/Railway/Fly.io/Cloudflare integration would close this gap.
+
+### 3. Figma/Design Import (MEDIUM PRIORITY)
+
+Both competitors support Figma import. Replit has deep MCP-based Figma integration plus a dedicated import flow. Lovable uses Builder.io's Figma plugin. Loki Mode has no design-to-code pipeline. Adding Figma MCP integration would address this.
+
+### 4. Real-Time Collaboration (MEDIUM PRIORITY)
+
+Replit supports shared project editing with agent-assisted merging. Lovable supports 20 simultaneous collaborators. Loki Mode is single-operator. While the CLI paradigm limits this, the dashboard could support multiple viewers, and the parallel worktree system could enable multi-developer coordination.
+
+### 5. Built-In Database and Auth (LOW PRIORITY)
+
+Replit and Lovable include database and authentication out of the box. Loki Mode generates code for whatever database/auth the user specifies, but does not provide managed infrastructure. This is by design (no lock-in), but "batteries included" templates for common stacks (Supabase, Firebase, Prisma+PostgreSQL) would accelerate initial setup.
+
+### 6. Pre-Built Connectors/Integrations (LOW PRIORITY)
+
+Replit has 30+ native connectors. Lovable integrates with Stripe, OpenAI via Supabase. Loki Mode has MCP support but no pre-built connector library. Building a curated set of MCP server configurations for common services (Stripe, Slack, Notion, etc.) would help.
+
+### 7. Mobile App Development (LOW PRIORITY)
+
+Replit now supports React Native/Expo with full backend and RevenueCat monetization. Lovable is web-only. Loki Mode can generate mobile code but has no specific mobile development workflow or templates.
+
+---
+
+## Actionable Recommendations
+
+### Tier 1: High Impact, Build Now
+
+**R1: Ship a "loki deploy" command with managed deployment targets**
+- Integrate with Vercel, Railway, Fly.io, Cloudflare Pages
+- Support custom domains, SSL, environment variables
+- One command: `loki deploy --target vercel`
+- This directly addresses the #1 UX gap vs both competitors
+- Estimated effort: 1-2 weeks
+
+**R2: Evolve the dashboard into a build-along interface**
+- Add live app preview (iframe to running dev server)
+- Add chat/prompt input for guiding autonomy
+- Add visual task queue with drag-to-reorder
+- Add build timeline with cost tracking
+- This makes Loki Mode accessible to technical PMs and designers
+- Estimated effort: 3-4 weeks
+
+**R3: Add Figma MCP integration**
+- Connect to Figma via MCP for design extraction
+- Generate component code from Figma frames
+- Replit and Lovable both have this; it is table stakes for design-to-code workflows
+- Estimated effort: 1 week (using existing MCP infrastructure)
+
+### Tier 2: Medium Impact, Build Next
+
+**R4: Create "starter kit" templates with built-in database/auth**
+- Supabase starter (React + Supabase + Tailwind)
+- Firebase starter (Next.js + Firebase)
+- Prisma starter (any framework + Prisma + PostgreSQL)
+- Each template includes auth, database, basic CRUD, and deployment config
+- This matches the "batteries included" experience of competitors without lock-in
+- Estimated effort: 2-3 weeks
+
+**R5: Build a cost estimator and budget dashboard**
+- Track API token usage per task, per iteration, per SDLC phase
+- Display running cost in real-time during autonomous execution
+- Project total cost at start based on PRD complexity
+- This leverages Loki Mode's cost transparency advantage with better UX
+- Estimated effort: 1-2 weeks (extends existing token_economics.py)
+
+**R6: Pre-built MCP connector library**
+- Package common MCP server configs: Stripe, Slack, Notion, GitHub, Supabase, OpenAI
+- `loki connect stripe` to add pre-configured MCP connector
+- Estimated effort: 2 weeks
+
+### Tier 3: Strategic, Build Later
+
+**R7: Multi-operator dashboard with shared project state**
+- Allow multiple developers to view and interact with an autonomous run
+- Share the dashboard URL for real-time monitoring
+- Enable task claiming (developer takes a task from the queue)
+- This addresses the collaboration gap without abandoning CLI-first philosophy
+- Estimated effort: 4-6 weeks
+
+**R8: Mobile development workflow**
+- Add React Native/Expo PRD template
+- Include mobile-specific quality gates (responsive design, touch targets)
+- Add mobile preview via Expo tunnel
+- Estimated effort: 2-3 weeks
+
+**R9: "Vibe mode" for non-technical users**
+- Simplified chat interface in dashboard
+- Auto-generates PRD from conversation
+- Handles all technical decisions internally
+- Targets the Replit/Lovable user base who want to build without knowing how
+- Estimated effort: 6-8 weeks (significant product expansion)
+
+### Competitive Messaging
+
+When positioning Loki Mode against Replit and Lovable, emphasize:
+
+1. **"No credit anxiety"** -- You pay your API provider directly. No surprise bills. No credits burned on AI mistakes.
+2. **"Production quality, not prototype quality"** -- 10 quality gates, 3-reviewer blind review, anti-sycophancy. Your code ships to production, not to a rewrite backlog.
+3. **"No lock-in"** -- Your code. Your infrastructure. Your choice of AI provider. Export is not a feature -- it is the default.
+4. **"Autonomous, not assistive"** -- Loki Mode does not wait for your next prompt. It plans, builds, tests, reviews, and deploys. You review the output, not babysit the process.
+5. **"Works with your codebase"** -- Legacy systems, brownfield projects, enterprise code. Not just greenfield MVPs.
+
+### Key Metrics to Track
+
+| Metric | Current State | 6-Month Target |
+|--------|---------------|----------------|
+| Time to first deploy | Manual | `loki deploy` in < 5 min |
+| Dashboard active sessions | Monitoring only | Build-along interface |
+| Figma integration | None | MCP connector live |
+| Starter templates | 13 PRD templates | +5 full-stack starter kits |
+| MCP connectors | 15 tools | 25+ tools with common services |
+| Cost transparency | Token tracking exists | Real-time cost dashboard |
+
+---
+
+## Appendix: Market Context
+
+### The "Vibe Coding" Explosion (2025-2026)
+
+The term "vibe coding" (coined by Andrej Karpathy) has driven explosive growth in AI app builders. Replit and Lovable are the two clear market leaders by revenue, but the space also includes Bolt.new, v0 by Vercel, Cursor, Windsurf, and numerous others. Key market dynamics:
+
+- **Total market size:** Estimated $10B+ by 2027 for AI-assisted development tools
+- **User base expansion:** Moving from developers to non-technical users (designers, PMs, founders)
+- **Revenue model convergence:** Credit-based consumption pricing is the norm, and also the #1 pain point
+- **Production quality gap:** All platforms produce adequate prototypes but struggle with production-grade output
+- **Lock-in risk:** Browser-based platforms increasingly lock users into proprietary infrastructure
+
+### Where the Market Is Heading
+
+1. **Credit fatigue will drive users to transparent pricing** -- Loki Mode's BYOK model becomes more attractive as credit complaints mount
+2. **Production quality will become the differentiator** -- Prototype generation is commoditized; who can ship production code wins
+3. **Enterprise adoption requires compliance** -- SOC 2, on-premises, audit logs become table stakes
+4. **Multi-agent orchestration is the next frontier** -- Replit Agent 4's parallel agents are primitive; Loki Mode's 41 agent types are ahead
+5. **Brownfield/legacy support is underserved** -- No competitor addresses existing codebases; Loki Mode's healing system is unique
+6. **Self-hosted alternatives are emerging** -- Projects like December (fully local Lovable/Replit alternative with own LLM) and Tinykit (self-hosted AI app builder) validate the demand for local-first, privacy-preserving alternatives. Loki Mode is already positioned here.
+
+### Emerging Open-Source Competitors
+
+| Project | Description | Relevance to Loki Mode |
+|---------|-------------|------------------------|
+| December | Local Lovable/Bolt alternative, runs with own LLM, Docker-based, Next.js | Validates BYOK model; Loki Mode is more capable |
+| Tinykit | Self-hosted AI app builder, code gen + deployment | Validates self-hosted demand; Loki Mode has deeper autonomy |
+| Auto-Claude | Electron desktop app, 12 parallel agents, Graphiti memory | Closest competitor in autonomous space; see existing analysis |
+| Bolt.new (open-source) | StackBlitz-based, browser IDE, on-prem available | Enterprise self-hosting option; Loki Mode is CLI-native |
+
+### Threat Assessment
+
+**Short-term (6 months):** Low threat from Replit/Lovable -- different target users. The real competition is Cursor + Claude Code for professional developers.
+
+**Medium-term (12 months):** Moderate threat -- as Replit/Lovable improve production quality and add enterprise features, they will attract more professional developers. Loki Mode must ship deployment, dashboard, and Figma integration.
+
+**Long-term (24 months):** High convergence risk -- all platforms will trend toward autonomous, production-grade, multi-agent systems. Loki Mode's quality gates, memory system, and brownfield support will be critical differentiators. The open-source model is an enduring advantage if the community grows.
+
+---
+
+## Research Sources
+
+### Replit
+- Replit 2025 Year in Review (blog.replit.com)
+- Replit Agent 4 Launch (blog.replit.com/introducing-agent-4-built-for-creativity)
+- Agent 3 to Agent 4 Changes (blog.replit.com/whats-changed-agent3-to-agent4)
+- Replit Pricing Page (replit.com/pricing)
+- Effort-Based Pricing Announcement (blog.replit.com/effort-based-pricing)
+- TechCrunch: $9B Valuation (techcrunch.com, Mar 2026)
+- The Register: Agent 3 Pricing Backlash (theregister.com, Sep 2025)
+- InfoWorld: Developer Dissatisfaction (infoworld.com)
+- Superblocks Replit Review 2026 (superblocks.com/blog/replit-review)
+- Replit Statistics 2026 (index.dev/blog/replit-usage-statistics)
+
+### Lovable.dev
+- Lovable 2.0 Announcement (lovable.dev/blog/lovable-2-0)
+- Lovable Series B ($330M) Announcement (lovable.dev/blog/series-b)
+- TechCrunch: $6.6B Valuation (techcrunch.com, Dec 2025)
+- Fortune: $200M ARR, Enterprise Ambitions (fortune.com, Nov 2025)
+- AI Tool Analysis: Lovable Review 2026 (aitoolanalysis.com/lovable-review)
+- Superblocks Lovable Review 2026 (superblocks.com/blog/lovable-dev-review)
+- eesel.ai: Honest Look at Lovable (eesel.ai/blog/lovable)
+- Lovable Documentation (docs.lovable.dev)
+- Medium: "Lovable is Doomed" Analysis (medium.com/utopian)
+- DesignRevision: Why Developers Switch Survey (designrevision.com)
+
+### Comparison Sources
+- Bolt vs Cursor vs Replit vs Lovable Guide (linkblink.medium.com)
+- "$500 Testing All Platforms" (medium.com/realworld-ai-use-cases)
+- AI For Dev Teams Comparison (aifordevteams.com)
+- Compete Network Analysis (thecompetenetwork.com)