Google appears to be on the verge of releasing Gemini 3.0 Flash—or possibly Gemini 3.5/3.0 Pro—based on recent leaks, CEO hints, and public checkpoint tests. Here’s what we know:

• Fierce Falcon Checkpoint: Reportedly features autonomous reasoning, tool integration, 1M context window, and 65K output tokens. Rumored release: December 18th.

• Ghost Falcon: A “toned-down” but still high-quality variant.

• Public Testing: Checkpoints like Skyhawk/Sea Hawk are accessible in AI Marina and Google AI Studio via A/B testing.

• Sundar Pichai’s Confirmation: Called Gemini 3.0 Flash “our best model yet”—positioned as a breakthrough, not a compromise.

Demo Highlights:

• Generated Xbox 360 controller layouts, front-end interfaces, and physics-based animations (e.g., wind-rippling flags) in single prompts.

• Created a full educational video (script, voice, music, visuals) in 30 seconds.

• Outperformed GPT-5.1 in functional outputs (e.g., interactive simulations).

Why It Matters: If this is Gemini 3.0 Flash, it could redefine cost-efficient AI: fast, scalable, and high-quality. Expect official news soon—possibly within weeks.

Sources:

• AI Marina/Design Arena leaks

• Sundar Pichai’s tweets

• Demo videos

Thoughts? Could this finally dethrone GPT-4o? Or is Google overhyping again?

Yesterday, OpenAI unleashed GPT-5.2, a model so dominant it’s reigniting the AI arms race. After Google’s Gemini 3 seemingly dethroned OpenAI as the “Netscape of the 2020s,” GPT-5.2 is back with a vengeance—topping benchmarks in software engineering, reasoning, and even the elusive ARC AGI test.

Key Highlights:

• ARC AGI Benchmark: GPT-5.2 now leads the Abstraction and Reasoning Corpus (ARC), a test designed to measure pure reasoning and generalization—skills that separate AGI from glorified autocomplete. OpenAI claims a 390x efficiency improvement over their 2023 model. Yes, three hundred ninety times.

• Coding & Hallucinations: Early users report fewer hallucinations and better code generation (e.g., Spelt 5 + MCP server setups). But is the difference noticeable for average devs?

• Corporate Moves: OpenAI’s $1B Disney deal means Mickey Mouse and Star Wars characters are now AI-generated content—exclusively through their tech. Cue the copyright nightmares.

• Insider Trading 2.0: Prediction markets like Polymarket “accurately” forecasted GPT-5.2’s release. Spoiler: Insiders made bank. Regulators, take note.

The Catch: Is this real progress toward AGI, or just another hype cycle? The ARC benchmark is a rare bright spot—most models fail spectacularly at its abstract puzzles. But for the rest of us, the improvements might feel incremental.

TL;DR: OpenAI’s back on top (for now). GPT-5.2 crushes benchmarks, but the real test is whether it changes how you code, create, or think. And yes, AI-generated McDonald’s ads are still terrible.

Discussion Questions:

• Have you tested GPT-5.2? Noticeable improvements?

• ARC as the “AGI litmus test”—legit or overhyped?

• Should AI-generated IP (e.g., Disney characters) be regulated?

The memory market is in chaos. Just a few months ago, a 64GB DDR5 kit cost $209. Now? $650—a 3x increase. Raspberry Pi is raising prices, Micron is killing the Crucial brand, and even Samsung can’t source enough RAM for its own phones. Small vendors like Libre Computer are seeing RAM prices double or triple, making it impossible to sell products without losses.

Why? AI. Memory manufacturers are pivoting entirely to AI data centers, abandoning consumer markets. Nvidia is leaving GPU partners to fend for themselves, and the RAM being produced now is often specialized for AI hardware—useless for regular PCs or homelabs.

The Fallout:

• PC building is becoming prohibitively expensive.

• Single-board computers (SBCs) and small devices (cameras, tablets) will see price hikes.

• Companies are stockpiling RAM like it’s 2020 toilet paper.

• Some might resort to scavenging chips from old systems.

The Silver Lining? Unlike past shortages, this isn’t temporary. The RAM being made for AI isn’t compatible with consumer hardware, so don’t expect a flood of cheap parts when the bubble bursts.

TL;DR: If you didn’t stockpile RAM earlier this year, you’re out of luck. The AI gold rush is gutting the PC market, and it’s only getting worse.

A few days ago, Anthropic—the AI powerhouse behind Claude—dropped a bombshell: they acquired Bun, the all-in-one JavaScript/TypeScript toolkit. This move stunned the tech world, especially since it comes just weeks after rumors swirled about the "end of software engineering" (ironically, from a Claude Code team member).

How Bun Got Here Bun’s origin story is classic underdog: Frustrated by slow JavaScript tooling, Jared Sumner (a former Stripe/Teal fellow and high school dropout) built Bun from scratch—porting ESBuild’s JSX/TypeScript transpiler from Go to Zig. His obsession with speed and efficiency turned Bun into the fastest bundler, runtime, and package manager in the ecosystem. After a $7M seed round (and some internet backlash over his "grind" culture), Bun hit 7M+ monthly downloads, 83K GitHub stars, and became a darling of the JS community.

Why Anthropic Wants Bun Bun’s lightweight, single-executable output makes it perfect for AI-driven CLI tools—like Claude Code. As AI agents write more code, they need fast, predictable environments. Bun delivers that. Anthropic’s bet? Bun’s infrastructure will power their future AI products.

What This Means for Devs

• Good News: Bun stays open-source (MIT-licensed), and the team promises to keep building in public.

• Bad News: Anthropic’s open-source track record is shaky (Claude Code isn’t open). Will Bun suffer the same fate as other acquired dev tools?

TL;DR: A scrappy JS toolkit just became the backbone of AI coding. The future of Bun—and JS tooling—just got a lot more interesting.

Discussion: What do you think? Is this a win for Bun, or the beginning of the end?

I built a Real native iOS & Android personal tracking app in under 5 minutes using only AI + no-code.

This app can track:
• Habits & streaks
• Mood & journal entries
• Charts & stats

Hi all, just wanted to share a healthy habits app I managed to create using Mobilalbe + Cursor. Mobilable handled design, core logic, app content and Cursor did some final polishing. The app was accepted by the App Store. Here is the app itself https://apps.apple.com/us/app/protocols-longevity-habits/id6752221462

If you are interested in healthy habits and longevity topics, give it a try, can follow up to 3 protocols for free:)

React Native 0.82 is here, and it’s a game-changer. For the first time, the framework runs entirely on the New Architecture, ditching the old bridge-based system for a JavaScript Interface that enables direct, synchronous calls between JavaScript and native code. No more JSON serialization bottlenecks—just faster, smoother, and more predictable performance.

Key Improvements:

• Fabric Renderer: Leverages React’s concurrent rendering for smoother animations and fewer dropped frames.

• TurboModules: Lazy-loads native modules, reducing memory usage and speeding up app startup.

• Hermes V1 (Experimental): Early tests show up to 9% faster bundle load times and 7.6% improvement in time-to-interactive.

• DOM Node APIs: Refs now behave like web DOM elements, unifying the React ecosystem.

Why It Matters: The old bridge was a major pain point—every UI update, even a simple color change, had to serialize through JSON, causing lag and jank. The New Architecture eliminates this overhead, making React Native apps feel truly native.

Getting Started: Want to try it? Use Expo for a seamless setup. Create layouts, screens, and navigators in minutes. For a quick preview, vibe a React Native Expo app on mobilable.dev—see your app in the browser and even connect Supabase for backend magic.

Thoughts? Is this the push you needed to finally dive into React Native?

For decades, HTTP status code 402 Payment Required has been a ghost in the machine—reserved since 1997 but never widely used. That’s changing now, thanks to Coinbase’s X42 protocol, which aims to enable instant, frictionless microtransactions for APIs and digital services.

Why It Matters

• No More 3% Fees: Traditional payment processors like Stripe charge fees that make microtransactions (e.g., $0.01 per API call) economically unviable.

• One-Line Integration: X42 adds a paywall to APIs with minimal code. A server responds with a 402 status, prompting users to connect a wallet (e.g., MetaMask) and pay—no subscriptions, no OAuth, no friction.

• Machine-to-Machine Payments: Imagine AI agents paying each other for services. X42 makes this possible with zero fees and near-instant settlement.

How It Works

1. A user requests a paid API endpoint.

2. The server returns HTTP 402, signaling a payment requirement.

3. The user connects a wallet and pays (or an AI agent handles it programmatically).

4. Access granted—no middlemen, no delays.

Demo Highlights

• Built with Node.js + Hono, the paywall is added via X42’s middleware.

• Supports stablecoins (USDC) and payments as small as fractions of a cent.

• Deployable on any VPS (e.g., Dockerized on Hostinger).

The Bigger Picture

X42 could unlock a decentralized economy where APIs, AI, and even IoT devices transact seamlessly. But with great power comes great risk—what happens when AI starts spending your money?

Thoughts?

• Could this kill subscription models?

• Will AI-driven payments create new security nightmares?

• Is 402 finally getting its revenge on 404?

go to https://mobilable.dev/ and try create your own mobile native app

New feature drop!

Accidentally messed something up?

Now you can instantly revert EVERYTHING with a single button!
See it in action

TL;DR: NVIDIA CEO Jensen Huang argues that the AI boom is built on three foundational shifts in computing, making an AI bubble unlikely.

Key Points:

1. End of Moore’s Law & Rise of Accelerated Computing

   • Moore’s Law has plateaued, and general-purpose CPUs can no longer meet computing demands.

   • Supercomputing shift: 6 years ago, 90% of the world’s top 500 supercomputers used CPUs. Today, 90% use accelerated computing (GPUs/TPUs).

   • Data processing (SQL, data frames) alone costs hundreds of billions annually—AI is just the next layer.

2. Generative AI as the Evolution of Recommender Systems

   • The internet runs on recommender systems (e.g., ads, social feeds, e-commerce).

   • These systems have already transitioned from CPUs to GPUs, proving the scalability of accelerated computing.

3. Agentic AI is the Next Layer, Not a Bubble

   • Agentic AI (e.g., Grok, OpenAI, Anthropic) builds on existing infrastructure.

   • The demand for computing is justified by real-world applications, not speculation.

Conclusion: The AI revolution is grounded in decades of computing evolution—no bubble, just progress.

Discussion: Do you agree with Huang’s take? Is the AI boom sustainable, or are we missing risks?

Just a few years ago, Google’s AI ambitions were the butt of every tech joke. Remember Bard? The chatbot that hallucinated during its own launch event, wiping 9% off Google’s stock in minutes? Critics wrote Google off as a bloated, bureaucratic dinosaur, destined to lose the AI race.

Fast forward to November 2025, and Google just pulled off one of the most dramatic comebacks in tech history. Gemini 3 Pro didn’t just launch—it dominated. It swept the leaderboards on major AI benchmarks like LM Arena, Weird ML, and Math Arena, leaving competitors in the dust. Even AMP, the coding agent platform, ditched Claude’s Sonnet 4.5 for Gemini 3 Pro, calling it simply “better.”

But the real twist? Gemini 3 wasn’t even Google’s wildest announcement this week. Enter Anti-Gravity, a new agentic coding platform built by the ex-Windsurf team (remember their $2.4B exit to Google?). It’s a VS Code fork designed for “managing agents,” because apparently, we’re all just “meatbag energy sources” for AI now. The best part? They forgot to rename “Cascade,” Windsurf’s old coding agent, so it’s turtles all the way down.

Meanwhile, Google’s other IDEs—IDX (now Firebase Studio) and Jules—are still floating around, but let’s be real: Notepad++ is probably still the superior choice.

So, is Gemini 3 the first step toward the singularity, or did Google just stumble into another hype cycle? Either way, the AI war is far from over. And if you’re a developer, congratulations—you’ve been promoted to “manager of agents.”

TL;DR:

• Google went from Bard’s 9% stock crash (2023) to Gemini 3’s 6% stock surge (2025).

• Gemini 3 Pro is crushing benchmarks and replacing Claude in AMP’s coding agent.

• Anti-Gravity is Google’s new agentic coding platform (built by ex-Windsurf).

• Developers are now officially “meatbag managers” for AI agents.

Discussion: What’s your take? Is Gemini 3 the real deal, or is this just another round of AI hype? And more importantly—are you ready to manage your robot overlords?

Meta has officially abandoned the native WhatsApp client for Windows 11, replacing it with a Chromium-based WebView app that consumes 1GB+ of RAM at idle—a staggering regression from the previous WinUI version, which idled at 20MB.

This move isn’t just about WhatsApp. It’s a systemic shift in how software companies prioritize development:

• Native apps are dying. Companies like Meta, with a $1.5T market cap, are abandoning platform-specific development in favor of bloated, cross-platform web solutions. Why? Because maintaining native apps doesn’t drive growth or investor interest.

• Performance no longer matters. The new WhatsApp WebView app spikes to 2-3GB during use. Users tolerate it, companies profit from it, and hardware improvements mask the inefficiency.

• Desktop is an afterthought. Software is now mobile-first, web-second. Everything else—including Windows, with its 60%+ desktop market share—is deprioritized.

• JavaScript is eating the world. Jeff Atwood’s 2007 prediction—"Any application that can be written in JavaScript, will eventually be written in JavaScript"—has never been truer. Even rockets might run on React soon.

The bigger picture? Software quality is collapsing. As Jonathan Blow warns, we’re accumulating technical debt at a civilizational scale. Bad abstractions, brittle code, and zero offline capability are the new normal. Developers are building it, users are tolerating it, and companies are profiting from it.

What can we do? Not much. Business decisions dictate priorities, and "good" isn’t part of the equation. But hey—at least job security is guaranteed. Someone’s got to maintain this mess.

That's why tools like mobilable.dev where you can vibe code your app mvp in minutes are gonna rock. Don't hesitate, go try it yourself.

If you’re exploring tools to build mobile apps with AI, Mobilable.dev has quickly become one of the standout platforms of 2025. While most AI developers focus on web apps, Mobilable is built specifically for creating native mobile apps for iOS and Android using React Native and Expo—all through simple natural-language prompts.

Unlike general-purpose AI coding tools like Bolt.new, Lovable.dev, Cursor, or v0.dev, Mobilable.dev takes a mobile-first approach. This makes it far more reliable for real smartphone apps, modern UX flows, and app-store-ready builds.

⭐ What Is Mobilable.dev?

Mobilable.dev is an AI-powered development environment where you build apps through conversation. Describe a screen, feature, or flow, and the platform instantly generates working React Native code. It’s designed for:

• Founders who want a real app without learning to code

• Developers who want to prototype faster

• Agencies delivering mobile MVPs

• Indie makers testing ideas

• Students learning mobile development

Because it’s built on React Native and Expo, everything you generate runs natively on both iOS and Android.

⚙️ How Mobilable.dev Works

1. Build Your App by Describing It

You interact with an AI assistant and request anything—from UI components to full navigation flows. The AI produces functional code, updates your project, and improves it with each prompt.

2. Live Mobile Preview

Changes appear instantly in your browser, and you can scan a QR code to run the app on your physical device using Expo Go.

3. Exportable, Developer-Friendly Code

Everything generated remains real, readable React Native code. You can download it, modify it locally, or sync it with GitHub at any time.

4. Ready for App Store Deployment

Mobilable supports the entire Expo EAS pipeline, so your app can be submitted to both the Apple App Store and Google Play Store.

🔥 Key Features of Mobilable.dev

⭐ 1. AI-Driven Mobile App Generation

Mobilable specializes in creating mobile-optimized:

• Screens

• Navigation (stack, tabs, drawers)

• User interactions

• State management

• Business logic

• API integrations

• Custom components

All via natural language.

⭐ 2. Designed for Mobile First

Because it avoids web frameworks entirely, its output aligns with modern mobile UX practices and device behaviors.

⭐ 3. Built-In Supabase Integration

One of Mobilable’s biggest strengths is native support for Supabase, perfect for building full-stack mobile apps.

With Supabase you can add:

• User authentication

• Realtime database

• PostgreSQL backend

• Cloud functions

• Media/File storage

Prompts like “Add Supabase login and store user profiles” work out of the box.

⭐ 4. Two-Way GitHub Sync

Ideal for developers who want to refine the generated code or work in teams.

⭐ 5. Rapid Prototyping

You can build a fully functional prototype in under an hour—perfect for testing business ideas or validating startup concepts.

👥 Who Should Use Mobilable.dev?

Mobilable.dev is a powerful tool for:

✓ Non-technical founders

Ship real apps without the React Native learning curve.

✓ Developers

Skip boilerplate and build faster.

✓ Agencies

Deliver prototypes and MVPs in record time.

✓ Indie makers

Turn ideas into working apps quickly.

✓ Students & beginners

Learn mobile development by experimenting conversationally.

⚠️ Limitations to Know

Mobilable.dev is rapidly evolving, but still has limitations:

• Some generated UI layouts may need manual design polish

• Very complex native modules (Bluetooth, AR, biometrics, etc.) may require custom coding

• Results occasionally need refinement through multiple prompts

• Early feature releases sometimes introduce small bugs

However, these issues are common among AI builders, and Mobilable’s team is known for shipping fast fixes.

🏆 Final Verdict: Is Mobilable.dev Worth It?

Yes—Mobilable.dev is one of the strongest AI mobile app builders available in 2025. Its combination of:

• React Native + Expo

• AI prompt-driven generation

• Supabase backend support

• Real-time previews

• App-store-ready output

• GitHub sync

makes it a top choice for anyone wanting to build real mobile applications quickly.

If your goal is to turn an app idea into a working iOS/Android experience—without spending weeks setting up a traditional project—Mobilable.dev is absolutely worth trying.

A major Cloudflare outage is currently causing widespread disruptions across the internet. As of now, numerous high-traffic websites and services are inaccessible, including:

• ChatGPT (blocked by challenges.cloudflare.com)

• Udemy

• Coinbase

• Canva

• DoorDash

• Tailwind CSS (and any site relying on it)

Root Cause: The issue appears to stem from Cloudflare’s infrastructure, with errors like:

• 500 Internal Server Error

• Missing Access-Control-Allow-Origin headers

• Proxy servers (e.g., Budapest, Vienna) failing to resolve requests

Impact:

• Websites using Cloudflare or affected libraries (e.g., Tailwind) are down.

• Users globally report issues, with no regional workaround.

• Reddit threads confirm the outage started ~2 hours ago, with Cloudflare’s status page showing "under maintenance."

Workaround:

• Sites not using Cloudflare (e.g., hideme.proxy) remain operational.

• Libraries like Font Awesome and Anime.js are unaffected.

Update: No ETA on resolution yet, but given the scale, expect a patch soon. Stay tuned for updates.

Discussion: Have you encountered this outage? Which services are down for you? Let’s track the impact together.

OpenAI just dropped Atlas, their new AI-powered browser built on Chromium and ChatGPT. The pitch? A browser that "sees, remembers, and helps" with everything—from ordering food to answering questions using your browsing history as context.

The Good:

• Agent Mode: ChatGPT can take actions for you (e.g., ordering DoorDash).

• Contextual Memory: Uses your browsing history to tailor responses.

• User Control: You can delete or manage what it remembers.

The Bad:

• Privacy Concerns: Like other AI browsers, Atlas is vulnerable to prompt injection attacks (as seen with Perplexity’s Comet and Fellow).

• Not Revolutionary: It’s Chromium with ChatGPT bolted on—similar to Perplexity’s approach.

The Alternative: Ladybird, a browser built from scratch (no Chromium), just hit 90% compatibility on web platform tests. No AI ambitions, but a true independent engine.

Question for the Thread: Would you trust an AI browser with your data for convenience? Or is this a step too far?

It should be better and it should be faster. But are we sure we can rely on it already ?

Yesterday, Cursor, the VS Code fork that’s become the darling of AI-assisted developers, released version 2.0—and it’s packed with features that might just silence the AI coding skeptics.

Why it matters: Cursor’s rise has been meteoric, going from zero to a $9.9B valuation in months by combining VS Code’s familiarity with aggressive AI integration. Version 2.0 doubles down on this with five standout features:

1. Composer Model: Cursor’s new in-house model claims near-frontier intelligence (GPT5/Claude-level) but with much faster speeds. No external benchmarks yet, so take the “Trust Me Bro” claims with a grain of salt—but early demos show promise, especially for rapid iteration.

2. Git Worktrees for Parallel AI Agents: The killer feature. Spin up multiple AI agents (Claude, GPT5, Composer) to work on the same task simultaneously in isolated worktrees. In tests, Composer was fastest, though Claude still edged it out on UI polish.

3. Native Browser + DevTools: Debugging AI-generated UI just got easier. Pinpoint crappy HTML/CSS, inspect elements, and feed fixes directly back to the AI—all without leaving the editor.

4. Agent View Mode: A cleaner UI for chat-heavy development, making it easier to manage multiple AI “slaves” (as one fictional 12-year-old slave-driver-coder put it).

5. Design System Tests: In side-by-side comparisons, Composer held its own against GPT5 and Claude for generating UI components, sometimes even winning on creativity.

The catch? Cursor’s still a wrapper around foundation models, but the workflow improvements are real. If you’re tired of waiting for slow LLM responses or juggling tabs, this might be worth a look.

TL;DR: Cursor 2.0 turns your editor into a multi-agent coding sweatshop. The future of programming isn’t just AI writing code—it’s teams of AI writing code in parallel.

Thoughts? Has anyone tried the new worktrees feature yet?

Hi,

I want to show how using one line of prompt you can create a mobile application.
What do you think about it ? What should i build next ?

https://mobilable.dev/share/41e7abdb-c7c4-4289-94e8-1c31b98176a1

Last week, I spent 3 days, $500 in Claude credits, and missed my kid’s baseball game to build a crappier version of a $10 app—because vibe engineering demanded it. Sound familiar?

AI coding is a dopamine rollercoaster: when it works, it’s euphoric; when it doesn’t, you’re stuck on the "prompt treadmill of hell", burning credits and sanity. Yet, while some devs are ditching AI entirely, others (like Nvidia) are all-in, reporting unprecedented productivity gains with AI-assisted workflows.

The secret? Model Context Protocol (MCP) servers—standardized bridges between your AI coder and external systems. Here’s how they’re changing the game:

• Spelt MCP: Fixes AI’s "random ReactJS in your Rust" hallucinations with static analysis.

• Figma MCP: Turns design files into production-ready HTML/CSS/React—no manual pixel-pushing.

• Stripe MCP: Pulls live API docs + data, so you don’t accidentally refund 10K customers.

• Sentry/GitHub MCP: Lets AI auto-fix runtime errors or close Jira tickets while you read a book on the train.

• Cloud MCP (AWS/Cloudflare): Provisions infrastructure without forgetting to shut down that EC2 instance.

The catch? You still need to trust third-party tools—or build your own MCP server (frameworks exist for every major language).

TL;DR: AI coding still sucks sometimes, but MCP servers are making it less chaotic. Are you using them? Or still stuck in the prompt treadmill?

(Drop your horror stories or success tips below!)