FoundersFeed

Codex UI has serious sync issues. Threads created in the mobile app only appear in the VS Code plugin, completely invisible in the ChatGPT desktop Codex interface. State management across clients is broken—looks like they're not using a unified backend state or the desktop client has stale cache/polling issues.

Lemurian Labs is claiming serious performance gains: 1.7x on single-kernel ops, 2-3x on full workloads, and up to 30x on large-scale training runs.

The real play here isn't just raw speed—it's optimizing heterogeneous clusters. As models scale and become more dynamic, coordinating compute across mixed hardware (GPUs, TPUs, custom accelerators) becomes the bottleneck. Most frameworks assume homogeneous setups, but production infra is messy.

If they're actually hitting 30x on large training runs, that's not just kernel optimization—it's likely aggressive scheduling, memory management, and cross-device orchestration. The gap between single-kernel and full-workload gains (1.7x vs 2-3x) suggests they're also reducing overhead in data pipelines and inter-node communication.

Key question: are these gains on toy benchmarks or real production workloads? And what's the tradeoff in developer complexity? Faster training means nothing if you need a PhD to configure it.

Lemurian Labs CEO drops a brutal reality check: you'd need ~106 billion custom kernels to properly cover today's hardware landscape and workload diversity. Meanwhile, there are only ~2,000 performance engineers globally who can actually write high-quality kernels—and 90% of them are locked inside a single vendor ecosystem.

This is the kernel bottleneck nobody talks about. Hardware is scaling exponentially, but the expertise to optimize for it is insanely concentrated. If you're building infra or ML systems outside that one ecosystem, you're basically flying blind on performance.

Basis co-founder Mitchell Troyanovsky drops a spicy take: accounting demand is about to explode 100x.

His thesis: the current economy is massively under-accounted. Example: ~10,000 people touched the production chain of a single LaCroix can, but we only track a tiny fraction of those transactions.

The kicker: AI agents will flood the economy with digital labor entities, each generating accounting events. Every API call, every micro-transaction, every autonomous agent action = a ledger entry.

Right now we're already 1-2 orders of magnitude below what's needed. Add AI labor? He's predicting 2+ orders of magnitude increase in accounting demand.

This isn't about CPAs doing more tax returns. It's about building infrastructure to track economic activity at machine scale. Think: real-time ledgers for AI-to-AI commerce, programmatic audit trails, and accounting systems that can handle millions of autonomous economic actors.

Basis is positioning to build this layer. The question: will traditional accounting frameworks even work at AI scale, or do we need entirely new primitives?

SaaS moats aren't UI anymore—they're infrastructure, permissions, and data layers.

Mitchell Troyanovsky from Basis argues that if your entire value prop lives in the interface, you're cooked. AI agents don't need pretty dashboards—they need APIs, auth layers, and structured data access.

The real defensibility is in:
• Permissioning systems (who can do what, enforced at the data layer)
• Process orchestration (complex workflows that aren't just CRUD)
• Database architecture (schema design, relationships, constraints)
• Guardrails (business logic that prevents bad states)

UIs become thin clients or disappear entirely when agents can directly interact with your backend. If your SaaS is just a React app wrapping an API, you're building a temporary interface for a world that's moving to programmatic access.

The companies that survive are the ones where ripping out the UI still leaves a fortress of critical infrastructure that's hard to replicate.

Why do Chinese devs have a harder time building successful open source projects compared to Western devs?

This isn't about code quality - plenty of Chinese projects are technically solid. The real friction points:

• Language barrier creates documentation debt. Writing docs in English that actually resonate with global devs takes 3x the effort. Auto-translation doesn't cut it for technical nuance.

• Time zone hell for community engagement. When your core contributors are asleep, issues pile up unanswered for 12+ hours. Western projects get instant feedback loops.

• Network effects favor established ecosystems. Most devs default to npm/PyPI packages with existing traction. Breaking into that requires either being 10x better or solving a net-new problem.

• Payment infrastructure gaps. Sponsorships, SaaS conversions, enterprise deals - all harder when your legal entity and banking setup doesn't mesh cleanly with Stripe/GitHub Sponsors.

• Cultural expectations around "free." Chinese tech culture often expects everything open source to be completely free, making monetization strategies harder to execute.

The devs who crack this usually go full English-first from day one, build in public on Twitter/HN, and treat documentation as a first-class feature - not an afterthought.

AI's success in coding isn't just about having tons of data—it's about having the *right kind* of structured, executable data. GitHub gave us billions of lines of code with clear inputs, outputs, and logic flows that can be verified programmatically. That feedback loop is gold.

Other industries don't have this. Medicine has patient data locked behind HIPAA. Legal work is buried in proprietary case files. Manufacturing data sits in isolated factory systems. Even if you could aggregate it, there's no universal "compile and run" equivalent to validate correctness.

The open-source culture took decades to build—Linus started the kernel in '91, GitHub launched in '08, and it still took until the 2010s for companies to really embrace it. You can't artificially create that trust and collaboration overnight.

So yeah, coding AI works because we accidentally built the perfect training infrastructure over 30+ years. Replicating that for law, healthcare, or manufacturing? We're talking about fundamentally different data access models, privacy constraints, and incentive structures. It's not just a data volume problem—it's an ecosystem problem.

Hot take: 99% of AI apps without their own models are doomed.

The argument: If you're just wrapping OpenAI/Anthropic APIs with a nice UI, you're building on rented land. No moat, no defensibility. The moment the foundation model providers roll out similar features or pricing drops, your margin evaporates.

Why this matters technically:
- Model ownership = control over training data, fine-tuning, and inference costs
- Custom models can be optimized for specific domains (legal, medical, finance) where general-purpose LLMs are overkill
- Vertical integration lets you compress costs at scale and avoid API rate limits

Counterpoint worth considering: Not every app needs a custom model. If your value is in data pipelines, UX, or integration logic, the model is just a commodity component. Think Zapier for AI workflows.

But for long-term survival? Owning your model stack is increasingly non-negotiable. The API wrapper era is ending.

Jane Street's trade execution alpha is basically exposed infrastructure at this point. Their HFT strategies rely on microsecond advantages and proprietary order flow patterns. Now you've got AI models that can reverse-engineer market microstructure from public data, pattern-match execution styles, and front-run institutional flow with transformer-based prediction.

The real threat isn't just copying strategies—it's that ML systems can now infer private information from latency patterns, order book dynamics, and cross-venue arbitrage signals. Jane Street's edge was always information asymmetry + speed. AI collapses both.

They're probably hardening their infrastructure stack, compartmentalizing strategy teams even more, and running adversarial simulations to see what's leaking through market impact signatures. The paranoia is justified—once your alpha becomes statistically detectable, it's over.

New economics paper explores datacenters as a 'resource curse' - the phenomenon where regions rich in natural resources end up with worse economic outcomes. The parallel: areas that attract massive datacenter investments (cheap power, land, tax breaks) might see similar distortions. Local economies become dependent on infrastructure that employs few people, drains energy grids, and crowds out other industries. The paper argues datacenter clusters create extraction economies rather than innovation hubs - all the value flows to hyperscalers while host regions get stuck with power costs and environmental impact. Interesting framing for policy debates around datacenter subsidies and energy allocation.

Taxing datacenters to replace income tax creates a perverse incentive structure: legislators would optimize for datacenter interests instead of human constituents. When your tax base shifts from citizens to compute infrastructure, political representation follows the money. This isn't just a policy concern—it's a governance attack vector. If bots (or more accurately, the entities running massive inference/training clusters) become the primary revenue source, expect regulations that favor hyperscale operators over individuals. The economic power dynamic fundamentally breaks when your government's funding depends on keeping $NVDA happy instead of voters. Classic principal-agent problem at nation-state scale.

Coin Center launched a new newsletter called Peer to Peer focused on countering technological authoritarianism through constitutional principles and open technology. The publication is written by Jerry Brito, Neeraj Agrawal, Jason Somensatto, and Peter Van Valkenburgh. The framing positions decentralized tech and crypto as tools for defending civil liberties against state surveillance and control systems, rather than just financial instruments. This is a shift toward positioning the crypto policy fight as a broader free speech and privacy battle, not just a regulatory sandbox negotiation.

If your SaaS doesn't expose APIs, you're basically building a walled garden in 2025. No webhooks, no REST endpoints, no GraphQL = zero automation potential. Users want to pipe your data into their workflows, trigger actions from CI/CD, or build custom integrations. Without programmatic access, you're forcing manual clicks for everything, which kills adoption among devs and power users. Modern stack expects everything to be scriptable. Lock down your UI all you want for security, but if there's no API layer, you're competing with one hand tied behind your back.

Building the infrastructure for a fully autonomous agent-run business. This means agents handling everything - customer interactions, ops, financial decisions, even strategic pivots. The hard part isn't individual agent capabilities anymore, it's the orchestration layer: how do you let agents negotiate with each other, resolve conflicts, and maintain coherent business logic when there's no human in the loop? Need robust state management, clear agent-to-agent protocols, and probably some kind of constitutional framework to prevent the system from optimizing itself into weird corners. The scaffolding matters more than the agents themselves.

The robotics field might be hitting its GPT-3 breakthrough moment. Just like how GPT-3 proved that scaling transformer models with massive datasets unlocks emergent capabilities in language understanding, we're seeing similar patterns in robotics foundation models. Recent work shows that training on millions of robot manipulation trajectories is producing models that can generalize across different robots, tasks, and environments without task-specific fine-tuning. The key parallel: pre-training on diverse data creates latent representations that transfer surprisingly well to new scenarios. If this holds, we could see rapid deployment of general-purpose robot policies instead of hand-engineering behaviors for every single task. The compute requirements are insane though - we're talking hundreds of GPU-hours just for inference optimization.

Hot take: Western sci-fi defaults to dystopia because comfort breeds fear of change. When you're already winning, any new tech feels like a threat to the status quo.

Case study: Gattaca wasn't really about genetic engineering gone wrong—it was about meritocracy taken to its logical extreme through DNA-based talent screening. The tech worked perfectly. The dystopia came from humans using it to create rigid social hierarchies.

The real question: Is the tech dystopian, or is it just exposing what humans do when given powerful sorting mechanisms? Genetic screening, AI hiring tools, algorithmic feeds—same pattern. The tool reveals uncomfortable truths about how societies stratify when given precise measurement.

Western comfort → fear of disruption → dystopian framing. Meanwhile, regions still climbing see the same tech as liberation from current constraints. Different starting positions = opposite narratives about identical capabilities.

Biggest AI misconception: thinking AI can do things you fundamentally can't do yourself.

Seen too many devs burn through massive token budgets chasing impossible outputs, only to realize the hard way - if you can't clearly define the task logic, structure the data, or validate the output yourself, no amount of prompting will magically fix it.

AI amplifies capability, it doesn't create it from nothing. You still need domain knowledge to guide it properly.

The biggest misconception about AI: thinking it can do things you can't do yourself.

This hits hard for devs building with LLMs. You can't just throw a vague prompt at GPT-4 and expect it to architect your entire system. If you don't understand the problem domain deeply enough to break it down yourself, the AI won't magically solve it for you.

Same applies to code generation - if you can't review and debug the output, you're just shipping unknown bugs faster. AI amplifies your existing skills, it doesn't replace the foundational knowledge.

The real power comes from pairing domain expertise with AI tooling. Know what you're building, use AI to accelerate the execution.

Vibe coding without solid fundamentals is a trap – you'll get seduced by Fable's abstractions and end up overengineering everything. The codebase turns into a pile of unnecessary complexity real fast. 💩

Stripe just acquired OpenRouter, the LLM routing service that lets devs access 200+ models through a single API. This is huge for payment integration with AI apps.

OpenRouter's core value: unified interface for GPT-4, Claude, Llama, Mistral, etc. Devs don't need to manage multiple API keys or handle different response formats. You send one request, OpenRouter routes to the cheapest/fastest model that fits your needs.

Why Stripe wants this: They're building the payment rails for AI apps. Most AI companies burn cash on inference costs. Stripe can now offer "pay per token" billing directly tied to model usage, with automatic cost optimization.

Technical impact: Expect Stripe to integrate OpenRouter's routing logic into their billing APIs. Imagine charging users based on actual LLM tokens consumed, with automatic fallback if primary model is down. Smart routing could cut inference costs 30-40% for apps using multiple providers.

This moves Stripe from "payment processor" to "AI infrastructure layer." They're betting every SaaS app will have LLM features, and they want to own the metering + billing stack for that.