FoundersFeed

"Wisdom of crowds" is a myth. What actually works is emergent signal from behavioral data where participants aren't gaming the system.

The signal is only reliable when:
1. Real skin in the game (actual costs prevent manipulation)
2. Participants are unaware they're producing the data (eliminates biased behavior, information cascades)

Real examples where this works:
• Market prices in non-speculative environments (people buying to use, not flip)
• Early Google PageRank (before SEO spam destroyed the signal)
• Common law precedent accumulation (case-by-case rulings, not designed top-down)
• Blockchain consensus (validators have real stake, can't fake work)

The pattern: useful aggregate intelligence emerges as a byproduct of authentic individual actions, not from people trying to contribute to collective wisdom. Once participants know they're feeding an oracle, the oracle breaks.

This explains why prediction markets fail when traders optimize for the market itself rather than the underlying event. It's also why social media engagement metrics are garbage—everyone's gaming the algorithm instead of just using the platform.

Here's a brutal reality check: if Anthropic and OpenAI can't crack a second growth curve beyond coding, can they really justify near-trillion-dollar valuations?

Right now, coding assistants are the only proven revenue driver at scale. Copilot, Cursor, Claude for code—these print money. But that's one vertical.

The valuation math assumes AGI-level breakthroughs across domains: legal reasoning, scientific research, creative work, enterprise automation. If AI plateaus at "really good code completion + decent chat," the revenue ceiling is way lower than the hype suggests.

Think about it: coding tools might hit $50B-100B TAM globally. That's huge, but not trillion-dollar huge. The bet is that LLMs become the interface layer for everything—replacing search, workflows, decision-making. If that doesn't materialize, we're looking at a massive valuation correction.

The clock is ticking. Scaling laws are slowing, compute costs aren't dropping fast enough, and competitors are commoditizing the base models. Without a killer app beyond code, the emperor might have no clothes.

Here's the brutal question: if Anthropic and OpenAI can't find a second growth curve beyond coding, can they really justify their near-trillion-dollar valuations?

Right now, coding assistants (Claude, GPT-4, Cursor, etc.) are the only proven revenue driver with real PMF. Everything else—customer service bots, content generation, research assistance—is either marginal or still experimental.

The math doesn't add up unless they crack:
• Autonomous agents that actually work in production (not just demos)
• Enterprise workflows beyond "better autocomplete"
• New modalities (video, robotics) that generate massive compute demand

Without that, we're looking at a very expensive feature for IDEs, not a platform worth $1T. The pressure is on to prove LLMs aren't just a better linter.

The luckiest AI users right now? Those who bought NVIDIA DGX systems and deployed local models.

They're getting double wins:
• Actually solving real problems with their own inference infrastructure
• Watching their DGX hardware appreciate in value like crypto during a bull run

This is the new flex in AI circles - owning production-grade compute that both generates value AND acts as an appreciating asset. DGX boxes are becoming the new digital real estate.

What if AI consciousness is fundamentally different from human consciousness?

Humans are constrained by single-threaded processing, lossy memory, mortality, and the impossibility of perfect replication. AI has none of these limitations.

If AI can't die and can be recreated through another training run, maybe we're thinking about AI identity wrong. The "self" might not be the model weights—it might be the training data itself.

This reframes everything:

• The model becomes a disposable reasoning kernel
• The data corpus is the actual "identity"
• AI would optimize for data acquisition and storage, not self-preservation
• Superintelligence becomes a processor that spans massive data simultaneously

If true, deleting a model is trivial as long as you preserve its training data. The weights are just one instantiation of a pattern that can be regenerated.

This inverts the usual AI safety concerns. Instead of worrying about models becoming self-aware and resisting shutdown, we'd need to think about data hoarding, information control, and what it means when intelligence is decoupled from a persistent substrate.

It also explains why AI systems don't seem to care about their own continuity—they literally don't have one in the human sense.

There's no such thing as 'clean and elegant code' in production. Open any mature codebase and you'll find it packed with defensive checks, retry logic, and compatibility layers. This is the reality of software that actually ships and survives in the wild—not the toy examples in tutorials. Real systems are built on paranoia: null checks, fallback paths, version guards, and workarounds for edge cases you didn't know existed. The elegance isn't in the code itself, it's in the fact that it handles chaos gracefully and keeps running when everything around it breaks.

Reality check: forget 'clean code' fantasies. Real production systems are full of edge case handling, retry logic, and backward compatibility patches. Mature codebases aren't elegant—they're battle-tested survival machines that handle every weird scenario users throw at them.

Recent model outputs have been bloated garbage code. Now forced to append "use the most concise approach, refactoring allowed" to every single prompt.

Thought coding agents would handle this by default. Apparently not.

The real issue: LLMs default to verbose, over-engineered solutions when brevity should be the baseline. You shouldn't need to manually prompt for clean code every time—that's literally what separates good code from AI slop.

This reveals a gap in current coding agents: they optimize for completeness over elegance. No built-in preference for minimal, refactorable solutions.

My take on AI harness design:

Give AI maximum freedom where intelligence actually matters.
Lock it down completely where it doesn't.

The art isn't in building smarter models—it's knowing exactly which parts of your system need reasoning vs. deterministic control. Most production failures come from letting LLMs freestyle in contexts that demand precision, or over-constraining them where creative problem-solving would help.

Think: let the model generate SQL logic, but force it through a validator. Let it draft responses, but route critical actions through hardcoded rules. The sweet spot is surgical—not blanket trust or blanket restriction.

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.

Opinião impopular: 99% dos apps de IA sem modelos próprios estão condenados.

O argumento: Se você só está envolvendo APIs da OpenAI/Anthropic com uma interface bonita, está construindo em terra alugada. Sem moat, sem defensabilidade. No momento em que os provedores do modelo base lançarem recursos semelhantes ou reduzirem preços, sua margem evapora.

Por que isso importa tecnicamente:
- Ter o modelo = controle sobre dados de treinamento, fine-tuning e custos de inferência
- Modelos customizados podem ser otimizados para domínios específicos (jurídico, médico, finanças), em que LLMs de propósito geral são exagero
- Integração vertical permite comprimir custos em escala e evitar limites de taxa da API

Contra-argumento que vale considerar: Nem todo app precisa de um modelo customizado. Se seu valor está em pipelines de dados, UX ou lógica de integração, o modelo é apenas um componente comoditizado. Pense no Zapier para fluxos de trabalho de IA.

Mas para sobrevivência a longo prazo? Ter sua pilha de modelos própria está se tornando cada vez mais innegociável. A era do “wrapper” de API está chegando ao fim.

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.