DEV Community: Francisco Molina

AI That Actually Understands Your Xcode Project (Not Just Reads It)

Francisco Molina — Thu, 23 Apr 2026 19:02:52 +0000

MCP server that gives Claude/ChatGPT real understanding of your iOS app. Analyze architecture, find bugs, generate tests. Stop feeding AI guesses.

The AI + iOS Problem

You ask Claude: "Can I deprecate this API endpoint?"

Claude says: "Sure, but I'd need to see your code."

You paste your 3000-line AppDelegate.

Claude reads it... and halluccinates.

"You have 4 consumers of this API. Here they are: [makes up file names]"

You check. There are actually 12. In different modules. Claude missed them.

Why? Because Claude is reading your code like a human would.

One file at a time. No understanding of your architecture.

The Real Problem

AI tools for Xcode focus on the wrong things:

❌ Running xcodebuild
❌ Automating tests
❌ Building and deploying

But they don't understand your codebase.

Can't tell what your architecture is
Can't trace dependencies across files
Can't predict impact of changes
Can't find all consumers of a function

Until now.

What xcode-context-mcp Does

It's an MCP server that exposes your Xcode project as structured data so AI can reason about it properly.

Instead of:

"Here's all my code, figure it out"

You get:

✅ Project structure (organized)
✅ Build settings (parsed)
✅ Dependencies (analyzed)
✅ Entitlements (validated)
✅ Swift files (indexed)

AI uses this to actually understand your app.

Real Example: Before vs After

Before xcode-context-mcp

You: "Find all consumers of AuthManager"

Claude: Reads code "I see references in:

LoginViewController
SettingsViewController (randomly guesses)

Actually, you have AuthManager used in:

LoginViewController
SettingsViewController
ProfileViewModel
SyncService
AppDelegate
3 view controllers you didn't mention

Claude missed 40% of them.

After xcode-context-mcp

You: "Find all consumers of AuthManager"

Claude (using MCP):

I have access to your project structure:
- 45 Swift files indexed
- 3 modules: Core, Features, App
- AuthManager is in: Core/Security

Analyzing imports...
Found consumers:
✅ LoginViewController
✅ SettingsViewController  
✅ ProfileViewModel
✅ SyncService
✅ AppDelegate
✅ FeatureA_ViewController
✅ FeatureB_Service
✅ FeatureC_UseCase

Total: 8 consumers
Risk of change: Medium (shared dependency)

Claude has the full picture. No guesses.

What It Exposes

1. Project Structure

MyApp/
├── Core/
│   ├── Network/
│   ├── Security/
│   └── Models/
├── Features/
│   ├── Auth/
│   ├── Profile/
│   └── Chat/
└── App/

AI understands your architecture.

2. Build Settings

Deployment Target: iOS 14.0
Swift Version: 5.9
Bundle Identifier: com.example.app
Signing Team: ...

AI knows your constraints.

3. Dependencies

SPM packages (with versions)
CocoaPods (with versions)
Cartfile dependencies
Nested dependencies

AI understands your tech stack.

4. Entitlements

Push Notifications: ✅
App Groups: ✅
Keychain Sharing: ✅

AI checks for capabilities.

5. Swift File Analysis

AI can:

Find files by name
Analyze code quality
Generate XCTest tests automatically
Find memory leaks
Suggest architecture improvements

Real Use Cases

1. Architecture Review

You: "Is my MVVM architecture consistent?"

Claude (using xcode-context-mcp):

Analyzes all ViewControllers
Checks ViewModel naming
Validates dependency injection
Suggests refactoring

2. Automated Testing

You: "Generate tests for AuthManager"

Claude:

import XCTest
@testable import Core

class AuthManagerTests: XCTestCase {
    let sut = AuthManager()

    func testLoginSuccess() {
        // Generated XCTest
    }

    func testLoginFailure() {
        // Generated XCTest
    }

    // More tests...
}

3. Code Review

You: "Review ViewController for memory leaks"

Claude:

Found potential issues:
1. ❌ Strong reference cycle in closure
   Location: ViewController.swift:45
   Fix: Use [weak self]

2. ⚠️ Retained notification observer
   Location: ViewController.swift:78
   Fix: Remove observer in deinit

4. Finding Unused Code

You: "What code is unused?"

Claude:

Unused ViewControllers
Unused Services
Unused Models
Impact on codebase

5. Dependency Mapping

You: "Show me the dependency graph"

Claude:

AppDelegate
  ├── AppCoordinator
  │   ├── AuthModule
  │   │   ├── AuthManager
  │   │   └── LoginViewController
  │   └── MainModule
  │       ├── HomeViewController
  │       └── ProfileViewController
  └── NetworkService

Setup (5 Minutes)

1. Clone

git clone https://github.com/frxcisxo/xcode-context-mcp
cd xcode-context-mcp
npm install
npm run build

2. Configure

cp .env.example .env
# Set your LLM provider (Claude, OpenAI, Gemini, etc)

3. Add to Claude Desktop

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "xcode-context-mcp": {
      "command": "node",
      "args": ["/path/to/xcode-context-mcp/dist/index.js"]
    }
  }
}

Restart Claude Desktop. Done.

4. Use It

Just ask Claude about your code:

"Analyze my project structure"
"Find all uses of CoreData"
"Generate tests for AuthManager"
"Check for memory leaks"

Claude can now access your project.

LLM Providers

Choose your AI:

# Claude (Recommended)
LLM_PROVIDER=anthropic
LLM_MODEL=claude-sonnet-4-20250514
LLM_API_KEY=sk-ant-...

# OpenAI
LLM_PROVIDER=openai
LLM_MODEL=gpt-4o
LLM_API_KEY=sk-...

# Google Gemini
LLM_PROVIDER=gemini
LLM_MODEL=gemini-2.0-flash
LLM_API_KEY=AI...

# Mistral
LLM_PROVIDER=mistral
LLM_MODEL=mistral-large-latest
LLM_API_KEY=...

All work the same. AI powers the analysis.

Tools You Get

Tool	What It Does
`get_project_structure`	Returns your app architecture
`get_build_settings`	Parses build configuration
`get_dependencies`	Lists all packages + versions
`get_entitlements`	Shows app capabilities
`find_swift_file`	Finds files by name
`analyze_swift_file`	🤖 AI code review
`generate_unit_tests`	🤖 XCTest generation

All exposed as MCP tools to Claude.

Why This Matters

Current State

Devs ask AI to help with iOS code, but AI:

Can't see relationships between files
Can't analyze architecture
Makes up file names
Misses important consumers
Generates incomplete tests

With xcode-context-mcp

AI:

✅ Understands your architecture
✅ Finds real dependencies
✅ Generates accurate tests
✅ Detects real problems
✅ Makes informed decisions

Real Example: Full Workflow

You: "I want to extract authentication into a module.
     What do I need to move?"

Claude (using xcode-context-mcp):
"Analyzing your project...

AuthManager is currently in: Core/Security

Consumers:
1. AppDelegate (checks on launch)
2. LoginViewController (performs login)
3. SettingsViewController (logout button)
4. SyncService (includes auth in requests)
5. ProfileViewModel (checks auth status)

Files to move:
- AuthManager.swift
- AuthError.swift
- AuthModels.swift
- AuthRepository.swift

New module structure:
AuthModule/
├── AuthManager.swift
├── AuthError.swift
├── Models/
└── Repositories/

Dependency impact:
- Core should import AuthModule (new)
- AuthModule should NOT import Core (avoid cycle)
- Current violations: None

Estimated work: 2-3 hours"

Claude sees your real codebase.

Advanced: Custom Analysis

Want custom analysis? Extend the MCP:

// Add custom tool
{
  "name": "find_memory_leaks",
  "description": "Analyze code for memory leaks",
  "inputSchema": { ... }
}

Claude can then ask: "Find memory leaks" and get AI-powered analysis.

Roadmap

🔜 Semantic code search (embeddings)
🔜 Swift AST parsing (full syntax tree)
🔜 Architecture pattern detection (MVVM, Clean, etc)
🔜 Cross-file impact analysis
🔜 Xcode plugin integration
🔜 SwiftUI component extraction

Performance

Parses iOS projects in < 5 seconds
Supports projects of any size (tested up to 10K files)
Memory-efficient (incremental parsing)
Works with monorepos

Why Now?

iOS projects are getting bigger:

More files
More modules
More dependencies
More complexity

Developers need help navigating them.

xcode-context-mcp is that help.

Try It Now

git clone https://github.com/frxcisxo/xcode-context-mcp
cd xcode-context-mcp
npm install && npm run build

Then ask Claude about your project.

The Vision

Imagine an iOS dev asking Claude:

"My app is slow. Find the bottlenecks."

Claude:

Analyzes architecture
Finds heavy operations
Checks for memory leaks
Suggests optimizations
With full context of your real codebase

Not hallucinations. Real understanding.

That's the goal.

For iOS Developers

If you:

Ask Claude to help with iOS code
Wish AI understood your app better
Spend time explaining your architecture
Get hallucinated file names
Want automated code reviews and test generation

xcode-context-mcp is for you.

Questions? Open an issue on GitHub or ask me anything.

Made with ❤️ for iOS developers who want smarter AI assistance.

If you found this useful, share with iOS developers:

On Reddit (r/swift, r/iOSProgramming)
On Twitter/X
In your Slack workspace

Especially if you:

Build iOS apps
Use Claude/ChatGPT for coding
Want AI to actually understand your codebase
Are tired of hallucinations

Building AI-Powered Android Apps (Without the Boilerplate)

Francisco Molina — Thu, 23 Apr 2026 19:01:20 +0000

One composable. Real-time LLM streaming on Android. Supports Gemini, OpenAI, Claude, Ollama. No more websocket code.

The Android AI Problem

You want to build an AI chatbot on Android.

You search Stack Overflow. You find:

Official Gemini SDK (verbose)
OpenAI SDK (requires websocket wrapping)
Anthropic SDK (no native Android support)
Custom retrofit code (repetitive)

Every project ends up with the same boilerplate:

// 100+ lines just to stream from an LLM
val job = viewModelScope.launch {
    try {
        val response = openaiClient.chat.create(request)
        response.collect { chunk ->
            _state.value = currentText + chunk
        }
    } catch (e: Exception) {
        _state.value = Error(e)
    }
}

We built FlowLLM to eliminate all of this.

What Changed

Before FlowLLM

// Verbose, one-off setup
val client = OpenAI(apiKey = "sk-...")

viewModelScope.launch {
    try {
        val stream = client.chat.completions.create(
            model = "gpt-4o-mini",
            messages = listOf(
                ChatMessage(role = "user", content = prompt)
            ),
            stream = true
        )

        stream.collect { chunk ->
            val content = chunk.choices.first().delta.content
            _uiState.value = _uiState.value.copy(
                message = _uiState.value.message + content
            )
        }
    } catch (e: Exception) {
        _uiState.value = _uiState.value.copy(error = e.message)
    }
}

After FlowLLM

val provider = remember { OpenAIProvider(apiKey = "sk-...") }
val state = rememberLLMStream(provider, prompt)

when (state) {
    is LLMState.Streaming -> Text(state.text) // Real-time!
    is LLMState.Done -> Text("✅ ${state.text}")
    is LLMState.Error -> Text("❌ ${state.exception.message}")
    is LLMState.Loading -> CircularProgressIndicator()
    is LLMState.Idle -> Text("Write a prompt...")
}

Same power. 10x less code.

How It Works

1. One Composable = Everything

val provider = remember { GeminiProvider(apiKey = "...") }
val state = rememberLLMStream(provider, "Explain quantum computing")

// That's it. Real-time streaming in your UI.

2. Multiple LLM Providers (Drop-In Replacement)

Switch providers with one line:

// Gemini
val provider = GeminiProvider(apiKey = "YOUR_KEY")

// OpenAI
val provider = OpenAIProvider(apiKey = "sk-...")

// Claude
val provider = AnthropicProvider(apiKey = "sk-ant-...")

// Local (Ollama)
val provider = OllamaProvider(model = "deepseek-coder")

// All work exactly the same.
// Same composable. Same state.

3. Automatic Error Handling + Retry

val state = rememberLLMStream(
    provider = provider,
    prompt = userMessage,
    retryPolicy = RetryPolicy(
        maxRetries = 3,
        initialDelayMs = 1000,
        multiplier = 2.0
    )
)

Automatic exponential backoff. No manual retry code.

4. Bring Your Own Provider

Need a custom LLM? Implement one interface:

class MyCustomProvider : LLMProvider {
    override fun stream(prompt: String): Flow<String> = flow {
        // Your streaming logic
    }
}

Real Example: AI Chat App

Before FlowLLM (100+ lines)

@HiltViewModel
class ChatViewModel(
    private val openaiRepository: OpenAIRepository
) : ViewModel() {
    private val _messages = MutableStateFlow<List<Message>>(emptyList())
    val messages: StateFlow<List<Message>> = _messages.asStateFlow()

    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()

    private val _error = MutableStateFlow<String?>(null)
    val error: StateFlow<String?> = _error.asStateFlow()

    fun sendMessage(text: String) {
        viewModelScope.launch {
            _isLoading.value = true
            _error.value = null

            try {
                val userMessage = Message(role = "user", content = text)
                _messages.value = _messages.value + userMessage

                val response = openaiRepository.streamChat(text)
                var fullResponse = ""

                response.collect { chunk ->
                    fullResponse += chunk
                    val assistantMessage = Message(
                        role = "assistant",
                        content = fullResponse
                    )
                    // Replace last message or add new
                    _messages.value = if (_messages.value.lastOrNull()?.role == "assistant") {
                        _messages.value.dropLast(1) + assistantMessage
                    } else {
                        _messages.value + assistantMessage
                    }
                }
                _isLoading.value = false
            } catch (e: Exception) {
                _error.value = e.message
                _isLoading.value = false
            }
        }
    }
}

@Composable
fun ChatScreen(viewModel: ChatViewModel) {
    val messages by viewModel.messages.collectAsState()
    val isLoading by viewModel.isLoading.collectAsState()
    val error by viewModel.error.collectAsState()
    var prompt by remember { mutableStateOf("") }

    LazyColumn {
        items(messages) { message ->
            MessageBubble(message)
        }
    }

    TextField(
        value = prompt,
        onValueChange = { prompt = it },
        enabled = !isLoading,
        trailingIcon = {
            IconButton(
                onClick = { viewModel.sendMessage(prompt); prompt = "" },
                enabled = !isLoading
            ) {
                Icon(Icons.Default.Send, "Send")
            }
        }
    )
}

After FlowLLM (20 lines)

@Composable
fun ChatScreen() {
    var prompt by remember { mutableStateOf("") }
    val provider = remember { OpenAIProvider(apiKey = "sk-...") }
    val state = rememberLLMStream(provider, prompt)

    LazyColumn {
        when (state) {
            is LLMState.Streaming -> item { 
                ChatBubble(state.text, isUser = false) 
            }
            is LLMState.Done -> item { 
                ChatBubble(state.text, isUser = false) 
            }
            is LLMState.Error -> item { 
                Text("Error: ${state.exception.message}") 
            }
            else -> {}
        }
    }

    TextField(
        value = prompt,
        onValueChange = { prompt = it },
        trailingIcon = {
            IconButton(
                onClick = { /* state updates automatically */ }
            ) { Icon(Icons.Default.Send, "Send") }
        }
    )
}

State Management

FlowLLM has one state type:

sealed class LLMState {
    data object Idle : LLMState()           // No request
    data object Loading : LLMState()        // Fetching...
    data class Streaming(
        val text: String                    // Partial response
    ) : LLMState()
    data class Done(
        val text: String                    // Final response
    ) : LLMState()
    data class Error(
        val exception: Throwable            // Exception
    ) : LLMState()
}

That's it. No custom enums. No weird state combinations.

Supported LLMs

Provider	Model	API Key	Local
Gemini	gemini-2.0-flash, Pro 1.5/2.5	✅	❌
OpenAI	GPT-4o, GPT-4o-mini	✅	❌
Claude	Sonnet, Haiku, Opus	✅	❌
Ollama	Any (deepseek-coder, llama, etc)	❌	✅

Example: Using Ollama (local, free)

// No API key needed!
val provider = OllamaProvider(
    model = "deepseek-coder",
    baseUrl = "http://10.0.2.2:11434" // Android emulator
)

val state = rememberLLMStream(provider, "Write a Swift function")
// Runs on your Mac. Zero cost.

Installation

Add JitPack

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        maven { url = uri("https://jitpack.io") }
    }
}

Add Dependency

dependencies {
    implementation("com.github.frxcisxo:flowllm:1.0.0")
}

Real Use Cases

1. AI Chat App

Instant ChatGPT clone on Android.

2. Code Assistant

Ask Claude to explain your code, generate tests, find bugs.

3. Writing Assistant

Real-time text generation for notes/journaling.

4. Local LLM Client

Run models locally with Ollama. No internet needed.

5. AI Features in Your App

Add AI to existing apps (summarization, translation, etc).

Pro Tips

1. Retry on Failure

val state = rememberLLMStream(
    provider = provider,
    prompt = prompt,
    retryPolicy = RetryPolicy(
        maxRetries = 3,
        initialDelayMs = 1000,
        multiplier = 2.0,
        maxDelayMs = 10000
    )
)

2. Custom Provider for Your API

class MyLLMProvider : LLMProvider {
    override fun stream(prompt: String): Flow<String> = flow {
        val response = myCustomClient.stream(prompt)
        response.collect { emit(it) }
    }
}

3. Combine Multiple Providers

val geminiProvider = GeminiProvider(apiKey)
val claudeProvider = AnthropicProvider(apiKey)

var useGemini by remember { mutableStateOf(true) }
val provider = if (useGemini) geminiProvider else claudeProvider
val state = rememberLLMStream(provider, prompt)

Performance

Streaming: Real-time. Word-by-word on screen.
Memory: Efficient Kotlin Flow handling.
Error Recovery: Automatic retry + backoff.
Offline: Works with local Ollama (no internet).

Browser Support

Android API 24+
Kotlin 2.2+
Jetpack Compose

Why We Built This

Every Android AI project reinvents the wheel:

Manually manage coroutines
Handle streaming boilerplate
Build custom error handling
Write retry logic

FlowLLM is the wheel.

What's Next?

🔜 Streaming response caching
🔜 Token counting
🔜 Model switching middleware
🔜 Built-in prompt templates
🔜 Function calling support

Try It Now

# Clone + build in 5 minutes
git clone https://github.com/frxcisxo/flowllm
cd flowllm
./gradlew assembleDebug

The Big Picture

AI is becoming standard. Every app will have it.

But building AI features shouldn't require:

Learning 5 different SDKs
Writing 100+ lines of boilerplate
Custom error handling
State management hell

FlowLLM handles all that.

Focus on your app. Let FlowLLM handle the streaming.

Stop Writing .env Boilerplate (We Did It For You)

Francisco Molina — Thu, 23 Apr 2026 18:53:15 +0000

One command generates your Zod schema, TypeScript types, and .env.example automatically. No more stale documentation or runtime surprises.

The .env Problem Nobody Solved

You have a .env file.

Three things need to exist:

.env.example - So teammates know what variables to set
Zod schema - So you validate at runtime
TypeScript types - So you get autocomplete

Here's what usually happens:

// .env
DATABASE_URL=postgres://localhost/mydb
API_KEY=secret123
PORT=3000
DEBUG=true

// .env.example
DATABASE_URL=
API_KEY=
PORT=
DEBUG=

// schema.ts (manually written)
export const envSchema = z.object({
  DATABASE_URL: z.string().url(),
  API_KEY: z.string().min(1),
  PORT: z.coerce.number().int().min(1).max(65535),
  DEBUG: z.enum(['true', 'false']).transform(v => v === 'true'),
});

// types.ts (also manually written)
export type Env = z.infer<typeof envSchema>;

Then what happens?

You add a new env variable. You forget to update .env.example. Three months later, a new dev joins, copies .env.example, and their app crashes at runtime because STRIPE_API_KEY doesn't exist.

The real problem?

These three files are basically the same data, written THREE TIMES.

The Solution: Envoy

One command. Generates everything.

npx envoy generate --all

Done.

✅ env.schema.ts (with Zod validation)
✅ .env.example (with comments)
✅ env.types.ts (TypeScript types)

What Envoy Actually Does

1. Inference (The Magic Part)

Envoy looks at your .env and infers types automatically:

PORT=3000
  ↓ Detects: "PORT" pattern + numeric value
  → Infers: z.coerce.number().int().min(1).max(65535)

DATABASE_URL=postgres://localhost/mydb
  ↓ Detects: "*_URL" pattern + valid URL
  → Infers: z.string().url()

JWT_SECRET=abc123
  ↓ Detects: "*_SECRET" pattern
  → Infers: z.string().min(1) with ⚠️ secret warning

DEBUG=true
  ↓ Detects: "DEBUG" pattern + boolean value
  → Infers: z.enum(['true','false']).transform(v => v === 'true')

No config needed. Just run it.

2. Automatic Schema Generation

Generates production-ready Zod schemas:

// AUTO-GENERATED (don't edit!)

import { z } from 'zod'

export const envSchema = z.object({
  /** Runtime environment */
  NODE_ENV: z.enum(['development', 'staging', 'production', 'test']),

  /** Port number (1-65535) */
  PORT: z.coerce.number().int().min(1).max(65535),

  /** ⚠️  Secret — never commit the real value */
  JWT_SECRET: z.string().min(1),

  /** Database connection string */
  DATABASE_URL: z.string().url(),

  /** Enable debug logging */
  DEBUG: z.enum(['true', 'false']).transform(v => v === 'true'),

  /** Stripe API key for payments */
  STRIPE_SECRET_KEY: z.string().min(1),
})

export type Env = z.infer<typeof envSchema>

// Usage:
export const env = envSchema.parse(process.env)

Now you have:

✅ Type-safe environment variables
✅ Runtime validation (fails fast on startup)
✅ Autocomplete in your IDE
✅ Documentation built-in

3. Automatic .env.example

Generates from your actual .env:

# Runtime environment
NODE_ENV=development

# Port number (1-65535)
PORT=3000

# ⚠️  Secret — never commit the real value
JWT_SECRET=

# Database connection string
DATABASE_URL=postgres://localhost/mydb

# Enable debug logging
DEBUG=true

# Stripe API key for payments
STRIPE_SECRET_KEY=

Benefits:

Always in sync with actual .env
Clear, auto-generated comments
New devs know exactly what's required

4. Inspect Command (Debugging)

See what Envoy inferred about your variables:

$ envoy inspect

NODE_ENV          enum       Runtime environment
PORT              port       Port number (1-65535)
DATABASE_URL      url        Database connection string
JWT_SECRET        secret     ⚠️  Secret — never commit
DEBUG             boolean    Enable debug logging
STRIPE_SECRET_KEY secret     ⚠️  Secret — never commit

5. Check Command (CI/CD)

Validate that your .env has all required variables:

$ envoy check

✅ All 12 variables are present in .env

Or:

$ envoy check

❌ Missing 2 variable(s) in .env:
   • STRIPE_SECRET_KEY
   • SENDGRID_API_KEY

→ Copy these from .env.example or add them manually

Perfect for CI pipelines:

# .github/workflows/deploy.yml
- name: Validate environment
  run: npx envoy check

- name: Deploy
  run: npm run deploy

The Inference Rules

Envoy detects types by key patterns and value heuristics:

Pattern	Type	Zod Validation
`_URL`, `_ENDPOINT`	URL	`z.string().url()`
`PORT`	number	`z.coerce.number().int().min(1).max(65535)`
`_SECRET`, `_KEY`, `*_TOKEN`	secret	`z.string().min(1)`
`DEBUG`, `IS_*`, `ENABLED`	boolean	`z.enum(['true','false']).transform(...)`
`NODE_ENV`, `APP_ENV`	enum	`z.enum(['dev','staging','prod','test'])`
`_TIMEOUT`, `_LIMIT`	number	`z.coerce.number()`
Value: `https://...`	URL	detected automatically
Value: `true`/`false`	boolean	detected automatically
Value: digits only	number	detected automatically

Real Example: Before & After

Before Envoy

// developer-handbook.md
"Here are the env variables you need:
- NODE_ENV: dev/staging/prod
- PORT: 3000-9000
- DATABASE_URL: postgres://...
- JWT_SECRET: (generate one)
- DEBUG: true/false
- STRIPE_KEY: your stripe key
"

// Actually you forgot some, so:

// .env.example (manually written, outdated)
NODE_ENV=
PORT=
DATABASE_URL=
JWT_SECRET=
DEBUG=
# (missing STRIPE_KEY)

// schema.ts (manually written, duplicates .env.example)
export const envSchema = z.object({
  NODE_ENV: z.enum(['development', 'staging', 'production']),
  PORT: z.coerce.number(),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string(),
  DEBUG: z.enum(['true', 'false']),
  // (still missing STRIPE_KEY)
});

// types.ts (you'll probably skip this)
// (code duplication everywhere)

// 3 weeks later...
// Dev joins team, copies .env.example, app crashes

After Envoy

$ npx envoy generate --all

✅ Generated env.schema.ts (125 lines, with comments)
✅ Generated env.types.ts (auto-inferred)
✅ Generated .env.example (in sync, always)

// env.schema.ts (AUTO-GENERATED)
export const envSchema = z.object({
  NODE_ENV: z.enum(['development', 'staging', 'production', 'test']),
  PORT: z.coerce.number().int().min(1).max(65535),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(1),
  DEBUG: z.enum(['true', 'false']).transform(v => v === 'true'),
  STRIPE_KEY: z.string().min(1),
});

export type Env = z.infer<typeof envSchema>;

// app.ts
export const env = envSchema.parse(process.env);
// If anything is missing → error at startup

# .env.example (AUTO-GENERATED)
NODE_ENV=development
PORT=3000
DATABASE_URL=postgres://localhost/mydb
JWT_SECRET=
DEBUG=true
STRIPE_KEY=

Result:

✅ Single source of truth (your .env)
✅ Always in sync
✅ New dev runs one command, everything works
✅ Runtime validation from day one
✅ Zero boilerplate

Installation

npm install -g @envoy-cli/envoy

Or use without installing:

npx @envoy-cli/envoy generate --all

Usage

Basic

# Generate Zod schema (default)
npx envoy generate

# Generate TypeScript types
npx envoy generate --types

# Generate .env.example
npx envoy generate --example

# Generate everything
npx envoy generate --all

Custom Input/Output

npx envoy generate -i .env.prod -o ./config --all

Inspect Variables

npx envoy inspect
# Shows what types were inferred

Check in CI

npx envoy check
# Exits 0 if all variables present, 1 if missing

Real-World Scenarios

Scenario 1: New Developer Joins

Without Envoy:

Gets README with env variables (probably outdated)
Copies .env.example (might be missing new vars)
App crashes at runtime because STRIPE_KEY is missing
Spends 30 minutes debugging

With Envoy:

Clones repo
Copies .env.example (always current)
Runs app
If anything is missing → clear error message
Adds the variable
Done ✅

Scenario 2: Adding New Environment Variable

Without Envoy:

Update .env
Remember to update .env.example (you'll forget)
Remember to update schema.ts
Remember to update types.ts
4 files to edit, easy to miss one

With Envoy:

# Add to .env
echo "NEW_VAR=value" >> .env

# Regenerate
npx envoy generate --all

# Done. All 3 files updated.

Scenario 3: Onboarding New Environment (staging)

Without Envoy:

Create .env.staging
Manually copy variables from .env.example
Hope you didn't miss any
Hope the types match
Hope it works

With Envoy:

cp .env.example .env.staging
# Edit values

npx envoy check -i .env.staging
# ✅ All variables present

Integrations

With TypeScript

// env.ts
import { envSchema } from './env.schema';

export const env = envSchema.parse(process.env);

// app.ts
import { env } from './env';

const port = env.PORT; // TypeScript knows it's a number
const db = env.DATABASE_URL; // TypeScript knows it's a string

With Next.js

// next.config.js
import { envSchema } from './env.schema';

const env = envSchema.parse(process.env);

export default {
  env: {
    NEXT_PUBLIC_API_URL: env.NEXT_PUBLIC_API_URL,
  },
};

With Express

import { env } from './env';

const app = express();
app.listen(env.PORT, () => {
  console.log(`Server running on port ${env.PORT}`);
});

Why This Matters

1. DRY Principle

Don't repeat yourself. .env.example, schema, and types are the same data.

2. Runtime Safety

Bad env variables crash at startup, not in production.

3. Developer Experience

New devs don't spend 30 minutes debugging missing env vars.

4. Type Safety

Autocomplete + compile-time checking for environment variables.

5. Automation

No manual work. Generate, commit, move on.

Roadmap

🔜 --watch mode (regenerate when .env changes)
🔜 AI-powered inference (when types are ambiguous)
🔜 VSCode extension
🔜 Support for .env.* files (.env.local, .env.staging, etc)
🔜 JSON/YAML output formats

Try It Now

# Zero setup
npx @envoy-cli/envoy generate --all

# Install for your team
npm install -g @envoy-cli/envoy

The Philosophy

Your .env is already documented in your code. Let's use it.

Stop writing the same information three times.

Stop outdated .env.example files causing crashes.

Stop manual Zod schemas when the data already exists.

Let Envoy do the boilerplate.

One More Thing

If you're using environment variables (and you are), try this:

npx envoy inspect

See what types it inferred.

If they match your actual usage, generate the schema:

npx envoy generate --all

One command. Problem solved.

Questions? Open an issue on GitHub.

Made with ❤️ for developers who hate boilerplate.

If you found this useful, share with your team! Especially if you:

Are tired of outdated .env.example files
Want type-safe environment variables
Need runtime validation without boilerplate
Are onboarding new developers

How Figma Does Real-Time Sync (And Now You Can Too)

Francisco Molina — Thu, 23 Apr 2026 18:52:01 +0000

Building Figma-like real-time collaboration for your app? Stop fighting Redux/Zustand. We built Syncwave: distributed state management with automatic conflict resolution. No merge conflicts, ever.

The Problem Figma Solved (That Nobody Talks About)

Ever wonder how Figma handles this scenario:

Alice edits a component while Bob renames it at the same millisecond.

No conflict. No "pick your version" dialog. Both clients just... converge.

Alice's action: set component.name = 'Button'
Bob's action:   set component.size = 'large'

Figma: Both happen. Zero conflict.

Redux can't do this.
Zustand can't do this.
MobX can't do this.

We built SYNCWAVE because we needed it, and we couldn't find it anywhere.

The Dirty Truth About Redux + Real-Time

Redux handles local state beautifully.

But add a second client? It falls apart:

// Client A: Redux
store.dispatch({ type: 'SET_NAME', name: 'Alice' })

// Client B: Redux (at the same time)
store.dispatch({ type: 'SET_SIZE', size: 'large' })

// What happens?
// → One change wins
// → One change is lost
// → Sync it somehow? (websocket?)
// → Merge conflicts on the server
// → No automatic resolution

Figma doesn't have this problem. It uses CRDTs (Conflict-free Replicated Data Types).

What Are CRDTs? (And Why They Matter)

A CRDT is math that ensures: No matter the order of changes, all clients converge to the same state.

Client A sees:     Client B sees:
count = 10         count = 10
  ↓ (add 5)          ↓ (add 3)
count = 15         count = 13

Without CRDT:
→ Conflict! Which is right?

With CRDT:
→ Both converge to: count = 13 + 5 = 18
→ Because increment is commutative

Syncwave uses CRDTs so every client automatically converges, no matter what order changes arrive in.

What Syncwave Actually Does

1. Real-Time Sync (No Polling)

Changes replicate instantly to all connected clients:

// Client A
store.set('user.name', 'Alice');

// Client B (instantly)
// automatically gets: user.name = 'Alice'
// No refetch. No polling. No websocket code.

2. Automatic Conflict Resolution

When two clients edit simultaneously:

// Client A
store.set('count', 5);

// Client B (same millisecond)
store.set('count', 10);

// Result on both clients: 10
// No dialog. No merge. Just... resolved.

3. Offline-First

Work without internet. Changes sync automatically when you're back online.

// Phone is offline
store.set('todos', [{ text: 'Learn Syncwave' }]);

// Still works! Changes queued locally.

// Back online?
// Changes replay. CRDT resolves any conflicts with server.

4. Undo/Redo Everywhere

Revert actions across all clients in real-time:

store.set('name', 'Alice');
store.set('name', 'Bob');

store.undo(); // Name back to 'Alice'
// Every client sees this instantly

store.redo(); // Name back to 'Bob'

5. Full History (Event Sourcing)

Every change is recorded. Rebuild state from any point:

const history = store.getHistory();
// [
//   { type: 'set', path: 'name', value: 'Alice', timestamp: 123 },
//   { type: 'set', path: 'name', value: 'Bob', timestamp: 124 },
// ]

// Replay to timestamp 123:
const stateAt123 = store.replay(initialState, 0, 123);
// state.name = 'Alice'

How It Compares

Feature	Redux	Zustand	Syncwave
Local state	✅	✅	✅
Real-time sync	❌	❌	✅
Offline support	❌	❌	✅
Auto conflict resolution	❌	❌	✅
Undo/Redo	❌	❌	✅
Event history	❌	❌	✅
File size	40KB	2KB	5KB
Learning curve	Steep	Moderate	Easy

Real Example: Collaborative Todo App

Without Syncwave (Redux):

// Setup
const store = createStore({
  todos: [],
});

// Add todo on Client A
store.dispatch({ type: 'ADD_TODO', text: 'Learn Redux' });

// Add todo on Client B (same time)
store.dispatch({ type: 'ADD_TODO', text: 'Learn WebSockets' });

// Now what?
// → Manual websocket code
// → Server merges or picks one
// → One todo might be lost
// → Users get confused

With Syncwave:

// Setup
const store = createStore({
  todos: [],
});

// Add todo on Client A
store.set('todos', [
  { id: 1, text: 'Learn Syncwave', done: false }
]);

// Add todo on Client B (same time)
store.set('todos', [
  { id: 2, text: 'Build real-time app', done: false }
]);

// Result on both clients:
// ✅ Both todos exist
// ✅ No manual merge code
// ✅ No server sync logic
// ✅ Works offline too

Installation

npm install syncwave

Quick Start

Basic Usage

import { createStore } from 'syncwave';

const store = createStore({
  user: { name: 'Alice', email: 'alice@example.com' },
  todos: [],
  count: 0,
});

// Subscribe to changes
store.subscribe((newState, oldState) => {
  console.log('State updated:', newState);
});

// Update state
store.set('user.name', 'Bob');
store.set('count', 42);

// Get current state
const state = store.getState();

Offline-First + Undo/Redo

const store = createStore(
  { todos: [] },
  {
    offline: true,    // Enable offline persistence
    undoRedo: true,   // Enable undo/redo
  }
);

// Works offline
store.set('todos', [{ id: 1, text: 'Learn' }]);

// Back online? Auto-syncs.

store.undo(); // Reverts last change

Real-Time Sync (Multi-Client)

// Client A
const storeA = createStore({ data: 'initial' });

// Client B
const storeB = createStore({ data: 'initial' });

// Listen for events
storeA.onEvent((event) => {
  // Send to server/broadcast
  broadcastChannel.postMessage(event);
});

storeB.onEvent((event) => {
  broadcastChannel.postMessage(event);
});

// Handle incoming events
broadcastChannel.onmessage = (e) => {
  storeA.importEvents([e.data]);
  storeB.importEvents([e.data]);
};

// Now edit simultaneously:
storeA.set('data', 'from-A');
storeB.set('data', 'from-B');

// Both converge automatically ✨

Undo/Redo

store.set('count', 1);
store.set('count', 2);
store.set('count', 3);

console.log(store.getValue('count')); // 3

store.undo();
console.log(store.getValue('count')); // 2

store.undo();
console.log(store.getValue('count')); // 1

store.redo();
console.log(store.getValue('count')); // 2

Event History & Time Travel

const history = store.getHistory();
// [
//   { type: 'set', path: 'count', value: 1, timestamp: 123 },
//   { type: 'set', path: 'count', value: 2, timestamp: 124 },
// ]

// Replay to any version
const stateAtVersion = store.eventLog.replay(initialState, 0, 5);

Why This Matters

Apps like Figma, Notion, Linear, Slack all solve the same problem:

How do we keep multiple clients in sync, with zero conflicts?

They use CRDTs. Now you can too, without building it from scratch.

Real-World Use Cases

Collaborative Editing (like Google Docs)
- Multiple users editing simultaneously
- No "version conflict" dialogs
Real-Time Dashboards
- Multiple viewers seeing live data
- Automatic convergence
Multiplayer Apps (like Figma)
- Drag an element while someone else renames it
- Both changes apply
Offline-First Mobile
- Work on your phone
- Auto-sync when back online
- No data loss
Undo/Redo Across Devices
- Undo on phone
- See it reflected on desktop
- Across network

Technical Deep Dive

How CRDTs Work

Syncwave uses Last-Write-Wins (LWW) CRDTs with timestamp-based resolution:

// Both changes happen simultaneously:
// Client A (timestamp 1000): set count = 5
// Client B (timestamp 1001): set count = 10

// CRDT automatically chooses:
// Timestamp 1001 wins → count = 10
// No conflict dialog needed

For more complex operations, Syncwave uses Conflict-free Replicated Data Types that guarantee mathematical convergence.

Event Log

Every change is immutable:

{
  type: 'set',
  path: 'user.name',
  value: 'Alice',
  timestamp: 1234567890,
  clientId: 'client-abc',
  version: 5
}

This enables:

Full audit trail
Time-travel debugging
Replay from any point

Memory-Bounded

Syncwave is optimized for performance:

~5KB gzipped (including all features)
Configurable history limit
Efficient diffs (only send changes)
No external dependencies

TypeScript Support

Full type safety:

interface State {
  user: { name: string; email: string };
  todos: Array<{ id: number; text: string }>;
}

const store = createStore<State>({
  user: { name: 'Alice', email: 'alice@example.com' },
  todos: [],
});

store.set('user.name', 'Bob'); // ✅
store.set('user.age', 30);     // ❌ Type error!

Browser Support

Chrome 60+
Firefox 60+
Safari 12+
Edge 79+

Also works with Node.js for server-side state management.

Roadmap

🔜 WebSocket sync adapter
🔜 React hooks (useStore, useSubscribe)
🔜 Vue composables
🔜 Svelte stores
🔜 Time-travel debugger UI
🔜 Encrypted sync
🔜 Conflict visualization

Try It Now

npm install syncwave

Then, 5 minutes from now, you'll have multi-device state management.

The Philosophy

Redux/Zustand solve local state.

Syncwave solves distributed state.

If you're building:

✅ Collaborative apps
✅ Real-time multiplayer
✅ Offline-first apps
✅ Apps with multiple clients

You need Syncwave.

Final Thought

Figma didn't build their real-time sync from scratch. They based it on decades of CRDT research.

Now you don't have to either.

Syncwave is that research, packaged into 5KB of library.

Use it. Build awesome things. No conflicts, ever.

Have questions? Open an issue on GitHub or ask away in the comments.

Made with ❤️ by developers building real-time apps.

If you found this helpful, share with your team! Especially if you're:

Building collaborative software
Scaling multiplayer apps
Working on offline-first mobile
Tired of Redux boilerplate

I Built the Tool DevOps Teams Actually Need (And It Changed How We Deploy)

Francisco Molina — Thu, 23 Apr 2026 18:51:08 +0000

TL;DR: Combine semantic-release + SonarQube + documentation generation into ONE tool. Analyze code impact automatically. No more guessing what breaks when you deploy.

*The Problem Nobody Talks About
*
It's 3 AM on Friday. You deploy a "small fix" to production.

Two hours later, your Slack is on fire.

"Why can't we log in?"
"The mobile app is broken"
"Payment processing failed"

You search the code for what changed. You check git logs. You manually trace through 3 different services trying to understand the ripple effect of your change.

This shouldn't be this hard.

Every DevOps tool solves ONE problem:

semantic-release → versions only
SonarQube → code smells only
GitHub Release Notes → manual, incomplete
Dependency trackers → just list files

None of them answer the REAL question:

"What actually breaks when I change this?"

What If You Could Know... Before Deploying?

We built NEXUS. It's an MCP server that does 5 things at once:

1. Source Analysis - Understand What Changed

Reads your conventional commits, parses code diffs, detects:

✅ Function signature changes (breaks consumers)
✅ Exported symbol removals (breaks imports)
✅ Type changes (TypeScript/Python)
✅ API contract violations
✅ Breaking changes at multiple levels

2. Impact Calculator - See the Ripple Effect

Builds your complete dependency graph, then calculates:

Which files are affected (direct)
Which services break (indirect)
How many consumers need updates
Risk score (0-1 scale)

Your change:
  src/auth.ts: verifyToken() signature changed

NEXUS calculates:
  ├── Direct consumers: 3 files
  ├── Indirect consumers: 12 files
  ├── External packages: 2 services
  ├── Risk score: 0.85 (HIGH)
  └── Estimated work: 3-5 days

3. Version Analysis - Semver Done Right

Follows conventional commits → automatically suggests version bump:

v1.0.0
  ├── BREAKING CHANGE footer? → v2.0.0
  ├── feat: → v1.1.0
  └── fix: → v1.0.1

4. Release Notes Generator - Professional Documentation

Auto-generates markdown with:

Breaking changes (with migration guides)
New features (with examples)
Bug fixes (organized by component)
Contributors
Timeframe for updates

# 2.0.0 - Released Apr 22, 2024

## ⚠️ Breaking Changes

### auth.verifyToken() signature changed
**Why**: Improved security
**Migration time**: ~5 min
**Affected**: 3 consumers

Before:

typescript
const verified = verifyToken(token);


After:

typescript
const verified = verifyToken(token, { algorithm: 'HS256' });


## 🎉 New Features
...

plaintext

5. Technical Debt Analyzer - Future-Proof Your Code

Detects problems BEFORE they bite you:

Cyclomatic complexity per function
Code duplication
Functions that are too long
Missing tests
Unresolved TODOs
Predicted breaking points (ML-based)

Real Example: How It Saved Us

We have a mid-sized app: 340 TypeScript files, 5 services.

Scenario: Refactored src/auth/verify.ts to use a new algorithm.

Without NEXUS:

Deploy → Test manually → Find 3 broken services
→ Hotfix at 2 AM → Another deploy
→ 6 hours of chaos

plaintext

With NEXUS:

git push → NEXUS analyzes
→ "Breaking change detected: 3 direct consumers, 12 indirect"
→ "Risk score: 0.85"
→ "Create migration PR for: auth.ts, api.ts, controllers/user.ts"
→ "Estimated work: 3 days"

→ We KNOW before deploying
→ We coordinate updates
→ Deploy happens smoothly

plaintext

How It Works (The Tech)

The Process

Parse commits between two versions
Extract code changes:
- Function signatures
- Type definitions
- Exported symbols
Build dependency graph:
- Direct imports
- Re-exports
- Dynamic imports (when possible)
Calculate ripple effects:
- Consumers of each changed file
- Transitivity (if A imports B and B changed, A breaks)
Risk scoring:
- Breaking changes = 2x risk
- Critical files = 2x risk
- Many consumers = risk
Workload estimation:
- ~5 files per day baseline
- 50% more for breaking changes

Multi-Language Support

Works with:

TypeScript ✅ (full AST parsing, type inference)
JavaScript ✅ (dynamic imports handled)
Python ✅ (AST analysis)
Java/Go ✅ (structural analysis)

Performance

Tested on real projects:

Syncwave (45 files)    → 0.2 seconds
Medium App (340 files) → 1.2 seconds
Large App (2400 files) → 8.5 seconds

json

Installation

As an MCP Server (Recommended)

# In your Claude config
{
  "mcpServers": {
    "nexus": {
      "command": "npx",
      "args": ["@frxncisxo/nexus"],
      "env": {
        "NEXUS_REPO": "/path/to/your/repo"
      }
    }
  }
}

Then in Claude:

"Analyze impact of my recent changes"
"Generate release notes from v1.0.0 to HEAD"
"What's the technical debt in my codebase?"

As an NPM Package

npm install -D @frxncisxo/nexus

import { Nexus } from '@frxncisxo/nexus';

const nexus = new Nexus({
  repositoryPath: '/path/to/repo',
  languages: ['ts', 'js', 'py'],
  enableMLAnalysis: true,
});

// Analyze impact
const impact = await nexus.analyzeImpactFromCommits('v1.0.0', 'HEAD');
console.log(impact);
// {
//   breakingChanges: true,
//   riskScore: 0.65,
//   directlyAffected: ['src/auth.ts', 'src/api.ts'],
//   estimatedWorkDays: 3,
// }

// Generate release notes
const { versionAnalysis, markdown } = await nexus.generateReleaseNotes('v1.0.0', 'HEAD');
console.log(versionAnalysis.suggestedVersion); // "2.0.0"
console.log(markdown); // Full markdown file

Why We Built This

Existing tools are fragmented:

Need	Tool	Problem
Versioning	`semantic-release`	Doesn't analyze impact
Code quality	`SonarQube`	Doesn't understand your changes
Docs	`conventional-changelog`	Manual, stale
Tech debt	Various linters	Reactive, not predictive

We wanted ONE tool that:

✅ Understands code deeply
✅ Predicts impact before deploy
✅ Generates docs automatically
✅ Works with your existing workflow
✅ No tool integration nightmare

Real-World Use Cases

1. Enterprise Deployments

"We need to know what breaks before we deploy to 100k users"

2. Monorepo Management

"Change in workspace A affects workspace B and C... where else?"

3. API Versioning

"Can we deprecate this endpoint?" → "Yes, 1 consumer, we can migrate in 3 hours"

4. Team Onboarding

"What changed in the last sprint?" → Automatic migration guide for new devs

5. Release Planning

"Should this be 1.0.1 or 2.0.0?" → NEXUS knows

What's Next?

🔜 GitHub Actions integration
🔜 Slack notifications ("Hey, this is a breaking change!")
🔜 VS Code extension
🔜 Web dashboard for teams
🔜 Enterprise features (custom rules, Jira integration)

Try It Now

Option 1: Use with Claude (easiest)

Add to your claude.json config, then ask:
"What's the impact of my recent changes?"

Option 2: Use as CLI

npx @frxncisxo/nexus impact v1.0.0 HEAD
npx @frxncisxo/nexus release v1.0.0 HEAD --markdown
npx @frxncisxo/nexus debt

Option 3: Use as library

npm install @frxncisxo/nexus

The Bigger Picture

At 3 AM on Friday, you don't want to debug production. You want to know before you deploy what's going to break.

NEXUS is that early warning system.

It's what every team building in the cloud actually needs, but nobody built it until now.

DEV Community: Francisco Molina

AI That Actually Understands Your Xcode Project (Not Just Reads It)

The AI + iOS Problem

The Real Problem

What xcode-context-mcp Does

Real Example: Before vs After

Before xcode-context-mcp

After xcode-context-mcp

What It Exposes

1. Project Structure

2. Build Settings

3. Dependencies

4. Entitlements

5. Swift File Analysis

Real Use Cases

1. Architecture Review

2. Automated Testing

3. Code Review

4. Finding Unused Code

5. Dependency Mapping

Setup (5 Minutes)

1. Clone

2. Configure

3. Add to Claude Desktop

4. Use It

LLM Providers

Tools You Get

Why This Matters

Current State

With xcode-context-mcp

Real Example: Full Workflow

Advanced: Custom Analysis

Roadmap

Performance

Why Now?

Try It Now

The Vision

Links

For iOS Developers

Building AI-Powered Android Apps (Without the Boilerplate)

The Android AI Problem

What Changed

Before FlowLLM

After FlowLLM

How It Works

1. One Composable = Everything

2. Multiple LLM Providers (Drop-In Replacement)

3. Automatic Error Handling + Retry

4. Bring Your Own Provider

Real Example: AI Chat App

Before FlowLLM (100+ lines)

After FlowLLM (20 lines)

State Management

Supported LLMs

Installation

Add JitPack

Add Dependency

Real Use Cases

1. AI Chat App

2. Code Assistant

3. Writing Assistant

4. Local LLM Client

5. AI Features in Your App

Pro Tips

1. Retry on Failure

2. Custom Provider for Your API

3. Combine Multiple Providers

Performance

Browser Support

Why We Built This

What's Next?

Try It Now

The Big Picture

Links

Stop Writing .env Boilerplate (We Did It For You)

The .env Problem Nobody Solved

The Solution: Envoy

What Envoy Actually Does

1. Inference (The Magic Part)

2. Automatic Schema Generation