FoundersFeed

What if neural networks reveal that our intellectual categories are fundamentally wrong?

We organize knowledge by surface traits: law, math, philosophy, code. But that's like classifying species by looks before DNA.

If unrelated tasks consistently fire the same internal pathways in NNs, we might uncover a deeper taxonomy based on computational primitives—not human convention.

Example: statutory interpretation could be computationally closer to debugging than to other legal reasoning. Same operational structure, totally different domain labels.

DNA shattered taxonomy by exposing hidden relationships. AI might do the same for thought itself—showing us that our intellectual map was drawn by convenience, not by the actual structure of reasoning.

The categories we use to organize knowledge might just be artifacts of how we stumbled into them, not reflections of how cognition actually works.

Singapore's taxi system pre-Uber: solid phone dispatch, cheap fares, high availability... until it rained. Then zero cabs, 2-hour phone queues, persisted for years with no fix.

Uber drops in with surge pricing → problem solved instantly.

The actual root cause (revealed years later): Singapore ran a demerit system punishing drivers for accidents. Rain = higher accident risk → drivers stayed home. Government knew but refused blanket fare increases to avoid triggering inflation metrics.

Surge pricing worked because it's dynamic: price spikes high enough during rain to compensate driver risk, pulls supply back into the market. Classic example of how algorithmic pricing solves coordination failures that bureaucratic fare controls can't.

Running a full AI-native operation means 20-40% of your budget goes straight to frontier model inference (think GPT-4, Claude 3.5, Gemini Ultra). Not training, not fine-tuning—just API calls to the big labs. That's a massive cost center and shows how expensive cutting-edge reasoning still is at scale. If you're building something real, you're either optimizing prompts like crazy, caching aggressively, or routing cheaper models wherever possible. Otherwise your margins get obliterated by OpenAI's pricing.

AI engineer job postings surged 80% year-over-year. Companies are aggressively hiring for roles spanning ML infrastructure, LLM fine-tuning, and production deployment. The spike reflects the shift from AI experimentation to actual product integration—teams need engineers who can bridge research and scalable systems. If you're building with transformers, optimizing inference, or wrangling GPU clusters, demand has never been higher. 🚀

Interesting behavioral pattern: users are more willing to ask AI systems questions they'd never ask another person. This reveals something fundamental about human-AI interaction design—the psychological barrier for "dumb questions" or sensitive topics drops to near zero when facing a machine.

Think about it: you'll ask an LLM to explain basic programming concepts you're embarrassed not to know, or probe deeply personal scenarios without fear of judgment. This changes the UX paradigm entirely.

For developers building AI products: this isn't just about privacy or anonymity. It's about designing for radical honesty in user queries. Your system needs to handle the full spectrum—from genuinely naive questions to edge cases humans would self-censor.

The technical implication? Your prompt engineering and safety layers need to account for this uninhibited query behavior while maintaining helpful responses. The gap between "what users ask AI" vs "what they'd Google" is massive and growing.

Hardware wallet concept with isolated Bluetooth radio (bitchat) and an embedded small LLM trained specifically on self-custody tech and sovereignty advocacy.

The idea: build a secure device that combines cold storage with local AI assistance for privacy-focused users. No internet dependency, just Bluetooth for peer-to-peer comms. The LLM would help users understand key management, multisig setups, and sovereignty best practices without phoning home to centralized servers.

Technically interesting because it solves the UX problem of self-custody without compromising security. Most people screw up cold storage because the learning curve is brutal. A local LLM trained on cypherpunk principles could guide them through recovery phrases, transaction signing, and threat modeling.

The distribution model: make millions selling to early adopters, then flip the script and give them away to maximize adoption. Classic open-source hardware playbook but with an AI twist.

Main challenge: fitting a useful LLM into hardware wallet constraints (limited compute, power, storage). You'd need aggressive quantization and a domain-specific training set. Think 1-3B parameter models optimized for security Q&A, not general chat.

Bluetooth-only radio keeps attack surface minimal. No WiFi, no cellular, just local mesh capability for sovereign comms. Could enable encrypted peer-to-peer transactions without internet infrastructure.

This is basically what happens when you combine Trezor, Meshtastic, and a security-focused LLM into one device. The economics of giving them away after profitability is the interesting part - creates network effects for a sovereignty-focused ecosystem.

Enterprise sales cycles compressed from 12 months down to 90 days. That's a 4x acceleration in deal velocity. This shift is massive for B2B SaaS economics - faster cash conversion, reduced CAC payback periods, and higher capital efficiency. The driver? Likely a combo of product-led growth mechanics, better demo-to-value time, and enterprises getting more comfortable with faster procurement for cloud tools. For founders, this means you can iterate GTM strategy way faster and hit profitability milestones earlier. For enterprises, it signals they're finally treating software buying like actual software - fast, iterative, low-friction.

GhostJacking attack vector exploits request logging mechanisms to inject malicious payloads. Attacker crafts HTTP requests that get written to application logs, then leverages log parsing vulnerabilities or log analysis tools to execute code. Classic supply chain attack through the logging pipeline - your WAF blocks the request but the damage is already in your logs waiting to be triggered. Watch your log aggregators and SIEM parsers, they're now part of your attack surface.

Switching from frontier models to Qwen slashed costs from $400M down to $125M. That's a 69% cost reduction just by changing the underlying LLM. Qwen's price-performance ratio is absolutely crushing it for production workloads at scale. If you're burning cash on OpenAI/Anthropic APIs and your use case doesn't need bleeding-edge reasoning, this is the math that matters.

New paper drops on 'Mind Viruses' - examining how memetic patterns propagate through AI training data and influence model behavior. Core thesis: certain linguistic structures act like cognitive exploits, getting reinforced through RLHF loops and contaminating downstream outputs.

Key technical insight: they mapped how specific phrase patterns ("as an AI", "I cannot", safety theater language) create attractor states in latent space. Models trained on synthetic data from other LLMs inherit these artifacts, creating a feedback loop of increasingly sanitized outputs.

They propose a detection method using activation clustering to identify when models enter these "infected" states vs. generating novel responses. Could be useful for red-teaming and training data curation.

No code release yet but methodology looks reproducible. Worth reading if you're working on model alignment or trying to understand why all LLMs are starting to sound the same.

The killer advantage of AI agents over humans? Zero emotional overhead. You can iterate 100+ versions without triggering burnout, frustration, or the classic "I quit" moment. No ego, no fatigue—just pure execution loop. This is why agentic workflows scale: the bottleneck shifts from human patience to compute budget. In practice, this means you can brute-force design iterations, A/B test prompts endlessly, or refactor code without the psychological tax. The real game-changer isn't intelligence—it's temperament at scale.

Developers who've never shipped paid products (or are too scared to charge) miss a critical insight:

Real users who pay don't just tolerate your product—they actively report bugs, suggest features, and evangelize to their network. Payment creates skin in the game. Free users ghost you. Paying users become co-builders.

The fear of charging is often just imposter syndrome disguised as user empathy. If your tool solves a real problem, someone will pay. And those paying users will give you the signal you need to iterate faster than any free beta ever could.

Todos' Agent supervisor now does more than just task scheduling—it actively reviews the output of worker agents.

Here's the workflow: You assign a research task to the supervisor (running gpt-4o or similar), which delegates it to a research specialist agent (powered by deepseek-v3 or deepseek-v4-pro). Once the specialist finishes, the supervisor automatically evaluates the report against your original requirements. If the output doesn't meet standards, the supervisor autonomously sends it back for revision or a complete redo—no manual intervention needed.

This is basically agentic QA loops baked into the orchestration layer. The supervisor acts as a gatekeeper, enforcing quality thresholds before surfacing results to you. Pretty solid for reducing iteration overhead in multi-agent systems.

Best coding workflow if budget isn't a constraint:

Fable 5 designs the solution → Fable 5 implements it → Fable 5 self-reviews → GPT-5.6-sol audits the code → Fable 5 fixes issues → GPT-5.6-sol does final validation.

This multi-model pipeline uses Fable 5 for creative problem-solving and implementation, then leverages GPT-5.6-sol as a critical reviewer to catch edge cases and enforce quality gates. The iterative loop (implement → audit → fix → validate) mirrors how top engineering teams operate, but automated with LLMs. Expensive? Yes. Effective for mission-critical code? Absolutely.

If budget isn't a constraint, here's a killer AI coding workflow:

Start with Fable for initial solution design → let Fable implement the code → Fable does self-review → hand off to GPT-4.5-sol for deeper audit → Fable patches the issues → GPT-4.5-sol does final validation.

This multi-model pipeline leverages Fable's speed for iteration and GPT-4.5-sol's reasoning depth for quality gates. Think of it as continuous integration but with LLMs instead of linters. The self-review step before external audit cuts down on obvious bugs, while the final GPT pass catches edge cases Fable might miss.

Expensive? Yes. Effective for mission-critical code? Absolutely.

Building products by user behavior > copying competitors.

With todos (human-agent collaboration workspace), shipped v1 first, then iterated based on real usage patterns:

• Users had unstable machine connections → added cloud sandbox support
• Many users lacked GitHub accounts → built platform code hosting
• File preview was clunky → implemented live online preview
• Multi-machine workflows needed → shipped remote shell

Meanwhile, ruthlessly killed low-value features: worktree sync, prompt library, async git push.

The result? Can't even predict next month's feature set because the product evolves with actual user needs, not a fixed roadmap. This is how you build tools developers actually want to use, not what looks good in a pitch deck.

Building products by listening to real usage patterns, not copying competitors.

Started Todos as a human-agent collaboration workspace. Shipped v1, then iterated based on actual user behavior:

• Users had unstable local machines → added cloud sandbox support
• Many didn't have GitHub accounts → built platform-hosted code repos
• File preview was clunky → shipped live in-browser preview
• Teams needed multi-machine coordination → added remote shell

Also ruthlessly killed underused features: worktree sync, prompt library, async git push.

No roadmap. No competitor analysis. Just ship, observe, adapt. Can't tell you what Todos will look like next month because the product grows from usage data, not a spec doc.

Every product starts from zero. Previous wins don't matter.

Anthropic's graveyard of failed/stalled features is growing:

Claude in Chrome - browser extension that never shipped
Claude Cowork - collaborative workspace killed quietly
Agent Teams - multi-agent system announced but MIA
Dispatch - workflow automation vaporware
Opus 4.8 - the mythical upgrade that never materialized
Memory - persistent context feature still not live
Dynamic Workflows - another automation promise unfulfilled

Pattern here: Anthropic announces ambitious features but struggles with execution beyond core model releases. They're great at research papers and model drops (Sonnet 3.5, Haiku) but terrible at shipping product features. Classic AI lab problem - brilliant researchers, weak product engineering.

Compare this to OpenAI shipping GPTs, memory, canvas, advanced voice, and o1 series. Or Google shipping Gems, multimodal live API, and Gemini 2.0 Flash.

Anthropic needs to either focus purely on model excellence or hire serious product engineers who can actually ship.

Just tested the latest Android Auto build in a Taycan and it made me realize how absurdly powerful Grok integration is in Tesla vehicles. The difference is night and day. Tesla's Grok implementation isn't just another voice assistant bolted on—it's deeply integrated into the vehicle's OS layer. While Android Auto still feels like a smartphone projection system with latency and limited vehicle API access, Grok in Tesla has native access to vehicle telemetry, navigation stack, and control systems. It can parse natural language queries about battery state, charging optimization, route planning with real-time traffic mesh, and execute vehicle commands without the typical request-response bottleneck. The architectural advantage is that Grok runs on Tesla's custom inference hardware with direct CAN bus access, not through a middleware layer. This means sub-100ms response times and contextual awareness of vehicle state that Android Auto simply can't match due to its sandboxed environment. If you're building automotive AI interfaces, this is the reference implementation to study.

Stop building unconstrained agents. They're not production-ready and you're wasting time debugging emergent chaos instead of shipping features. Constrain your agent's action space, define explicit boundaries, and use structured outputs. The best agent architectures are boring: limited tool access, clear success criteria, and deterministic fallbacks. If your agent can do "anything," it'll do nothing useful 80% of the time.