I’ve spent the last week testing Codex 5.4 (via the VS Code extension on a Plus trial) while working on my core projects, LMSA and audio-forge. I went in expecting just another incremental update, but I’m walking away with a new favorite tool for implementation.

Here is why it’s actually competing for my "primary" slot.

1. The "Thinking" Trade-off: Precision Over Speed The first thing you notice about Codex 5.4’s high-reasoning mode is that it isn’t fast. If you’re used to the near-instant streaming of Gemini or the snappy responses of Claude, the "thinking..." pause in Codex might feel like a step backward.

But here is the reality of modern development: I would rather wait 15 seconds for a model to think than spend 15 minutes debugging a fast hallucination. When working with a complex React and Tailwind stack, minor logic errors in state management or Vite configurations can lead to massive headaches. While other models sometimes "hallucinate" a solution that looks right but fails on execution, Codex 5.4 consistently hits the mark the first time. It’s like working with a Senior Dev who takes a breath before answering, rather than a Junior who blurts out the first thing that comes to mind.

1. Closing the "Anxiety Gap" The most significant shift I noticed during this trial wasn’t about raw power—it was about trust.

We’ve all experienced that moment of hesitation before hitting "Apply" on an AI-generated refactor. You worry that fixing a CSS alignment issue in the audio-forge dashboard might somehow break the playback logic three files away. This "Anxiety Gap" is what usually keeps me from using AI agents for anything mission-critical.

With Codex 5.4, that worry started to fade. Its agentic reasoning seems to have a much better grasp of the "blast radius" of a code change. I found myself less worried about breakage and bugs because the model actually accounts for the downstream effects of its suggestions. It’s the first time an AI agent has felt like a pair programmer I can actually trust with the "keys" to the repo.

1. The One-Shot Standard Because 5.4 doesn't fall behind on context, it has the "big picture" view of the LMSA codebase. However, where it pulls ahead is in its one-shot accuracy.

Claude remains my favorite for high-level architectural brainstorming.

Gemini is my go-to for rapid-fire questions and multimodal tasks.

Codex 5.4 has become my go-to for implementation.

When I need to refactor a massive hook or integrate a new API, I don't want a "conversation"—I want a solution that works on the first try. Codex delivers that "one and done" experience more consistently than anything else I’ve used this year.

The Verdict Is Codex 5.4 "better" than Gemini or Claude? In terms of raw context or speed, it’s a level playing field. But in terms of reliability and logic, it has carved out a unique space.

If you’re tired of "babysitting" your AI and want a tool that respects the integrity of your code as much as you do, the 5.4 high-reasoning model is worth the trial. It might take longer to "think," but the time you save in debugging makes it the faster choice in the long run.

But after a few weeks of searching for a cheap way to get AI agents working inside VS Code, I decided to give it one more shot. I realized I was looking at the math the wrong way.

The Unlimited Loophole

The big mistake I made was assuming every single question I asked the Copilot Agent would eat into that 300-request bank. That is not the case.

The real secret to making the $10 a month plan worth it is the unlimited access to the standard models. Specifically: GPT-5 Mini and Raptor Mini.

These models are very competent for a wide range of small and medium tasks. Even when I am pushing them hard, GPT-5 Mini handles things like unit tests, boilerplate code, or simple refactors with no issues. Raptor Mini is great when I need the AI to look at my entire folder structure.

The best part is that using these models costs zero premium points.

Behind the Scenes: GPT-5 Mini and Raptor Mini

To understand why these models are "good enough" to be your primary tools, it helps to look at where they came from.

• GPT-5 Mini: This is part of the latest generation of OpenAI's "small but mighty" family. It was fine-tuned specifically for the Copilot ecosystem. It has a surprisingly large context window—around 264,000 tokens—which is why it does not "forget" your code as easily as older small models did. It is built for speed and high-accuracy code completion.

Raptor Mini (Raptor): This is an experimental, code-first model hosted by Microsoft on Azure. While GPT-5 Mini is a great all-rounder, Raptor was purpose-built for workspace-scale tasks. It is optimized for tool-calling and "agentic" behavior, meaning it is better at looking across multiple files and applying changes in parallel. If you are asking Copilot to "update this pattern across the whole project," Raptor is usually the one doing the heavy lifting in the background.

The 50/50 Split

Even with a heavy workload, I found that I do not need the most expensive model for everything. In my experience, the work splits about 50/50.

Half of my tasks are things the unlimited models can handle without breaking a sweat. The other half involves deep architectural problems or complex logic that requires the heavy hitters. When you look at it that way, those 300 premium requests become a specialized tool.

I save them for the really hard stuff, like fixing a deep logic bug or planning a massive change. 300 requests is a lot of "heavy lifting" for a month if you are not wasting them on things the standard models are already good at.

The Trial and Error Tax (and why you need Git)

Is it perfect? No. There is definitely a time tax here. Because you are trying to stay on the cheap plan, you have to spend time doing some testing to see which model can actually finish the job.

My workflow usually looks like this now:

1. Try the task with GPT-5 Mini.

2. If it gets confused, I try Raptor Mini.

3. If I am still stuck, only then do I use a premium request.

Because of this trial and error, using Git for version control is a must. When you are letting an agent experiment with your code, you need a safety net. I make sure I have a clean commit before I let a smaller model attempt a refactor. If it makes a mess of the file, I just revert and try again or move up to a premium model. Without a solid Git workflow, this method can become a headache very quickly.

The Bottom Line

I ignored Copilot Pro for a while because that 300 number scared me off. But after giving it a real chance, I found that the unlimited models are the real stars of the show.

If you want a low-cost way to get an AI agent in your editor, do not let the cap stop you. Just make sure you try the "Mini" models first before you start burning your premium requests. Even for heavy use, it is a lot of value for ten bucks.

2026 Plan Comparison: Free vs. Pro vs. Pro+

If you’ve been following my recent projects, you know I’ve been leaning heavily into agentic coding. Tools like Claude Code and Cline have fundamentally changed how I ship code. But lately, I’ve hit a wall—not a technical one, but a financial and logistical one.

Between the $15/1M input token cost for Claude Opus 4.6 and the constant "rate limit reached" messages that kill my flow, I started looking for a more sustainable way to work.

That’s when I came across the GLM Z.ai Coding Plan. After testing it for a few weeks, I think it’s the best-kept secret for developers who want "Opus-level" intelligence without the enterprise price tag.

The Reality of the "Claude Tax"

We all know Claude Opus 4.6 is the current gold standard for complex reasoning. But for a solo dev or a small team, the API costs are brutal. If you’re using an agent that makes 20+ calls to refactor a single component, you can burn through $10 faster than you can finish your coffee.

Z.ai (formerly Zhipu AI) changed the math for me. Instead of pay-as-you-go tokens, they use a 5-hour refresh cycle.

The Plan Breakdown (2026 Update)

The biggest draw for me was the entry price. You can actually get started for \(3/month on their Lite plan, though for my daily workflow, the Pro plan at \)15/month is the sweet spot.

• Lite Plan ($10/mo): About 80 prompts every 5 hours.

• Pro Plan ($30/mo): About 400 prompts every 5 hours.

• Max Plan: ($80/mo): For those doing 1,600+ prompts every 5 hours.

One "prompt" usually equates to 15–20 model invocations as the agent works through your task. When you do the math, the monthly quota you get is worth roughly 15–30x what you'd spend on raw tokens.

Does it actually code? (The Benchmarks)

I’m always skeptical of "affordable" models. If the reasoning isn't there, it's just a waste of time. However, the GLM-5 model—which is currently supported on the Pro and Max plans—is built specifically to compete with Claude Opus.

Here’s how it looks on the SWE-bench Verified (the standard for autonomous software engineering) as of February 12, 2026:

Is it a 1:1 replacement? Claude still has a ~3% edge in deep architectural reasoning. But for 95% of my daily tasks—debugging React hooks, writing Go backends, or managing Docker scripts—I can’t tell the difference. Plus, GLM-5 clocks in at 55+ tokens per second, so it’s noticeably snappier than Opus and gets the job done.

The "Agentic" Perks

What sold me on Z.ai wasn't just the model; it was the integration. It works out of the box with Claude Code, Cline, Roo Code, OpenClaw, and even newer tools like Goose and Crush.

They also include free MCP (Model Context Protocol) tools. My agents now have native:

• Vision Understanding: I can feed it a UI screenshot and it writes the CSS.

• Web Search/Reader: My agent can actually go out, read the latest docs for a library, and use that info in the code.

How to Set It Up

It’s surprisingly low-friction. If you’re using Claude Code, you just update your environment variables in your settings.json:

• Heavy Lifting: Map ANTHROPIC_DEFAULT_OPUS_MODEL to GLM-5.

• Standard Tasks: Map ANTHROPIC_DEFAULT_SONNET_MODEL to GLM-4.7.

• Fast/Cheap Tasks: Map ANTHROPIC_DEFAULT_HAIKU_MODEL to GLM-4.5-Air.

Final Thoughts & A Little Discount

If you're tired of watching your API balance vanish or getting throttled by Claude Pro's chat limits, this is worth a look. Z.ai is based in Singapore and has a solid privacy policy (they don't store your prompts or code).

I've been using it to cut my monthly AI spend by about 70% without losing productivity. If you want to try it out, I have an invite link that will knock an extra 10% off your plan.

🚀 Join the GLM Coding Plan Full support for the tools you already use, starting at just $3/month.

👉 Grab the 10% Discount Here

The discount applies automatically at checkout when you pick your cycle.

Today, I’m excited to announce a special initiative. To show my gratitude for their service and sacrifice, I am giving away 500 free promo codes for the premium, ad-free version of LMSA to Active Duty military and Veterans.

What is LMSA? (LM Studio & Ollama Mobile AI)

For the uninitiated, LMSA is a mobile interface that connects your phone to local AI servers like LM Studio and Ollama. It allows you to chat with powerful Large Language Models (LLMs) like Llama 3, DeepSeek, or Phi-4 directly from your pocket—without your data ever leaving your local network.

Key Features for Power Users:

• Total Privacy: No cloud tracking, no data collection. Your conversations stay on your hardware.

• Model Switching: Swap between different GGUF models on the fly.

• AI Voice Chat (TTS): Hands-free interaction with natural-sounding AI voices.

• Prompt Library: Save and manage complex system prompts for specialized workflows.

Why I'm Dedicating This Quarter's Codes to the Military

Google Play allows developers to generate 500 promo codes every three months. For this quarter, I’ve decided to skip the usual marketing pushes and give every single one of those codes to our service members.

Many in the military community deal with sensitive information and value the "air-gapped" nature of local AI. Whether you're using LMSA for productivity, learning, or just experimenting with the latest models, I want you to have the best possible experience, completely ad-free.

How to Claim Your Ad-Free Access

I’m keeping the verification process simple but manual to ensure these codes reach the right hands:

1. Email Me: Send a message to discount@lmsa.app with the subject: "LMSA Military Access."

2. Verify Your Status: You can email me from a .mil address.

3. Redeem: I’ll reply with a promo code that unlocks the ad-free version of LMSA in the Google Play Store instantly.

Spread the Word

If you have a friend in the service or a fellow vet who is into self-hosting or AI, please share this post with them. We have 500 codes available on a first-come, first-served basis.

LMSA is an independent project and is not affiliated with, or endorsed by, the Department of Defense (DoD), LM Studio, or Ollama. This giveaway is a personal thank you from the developer.

But let’s be honest: tapping out "Act as a senior Python developer and only output code" on a mobile keyboard every single time you start a new chat gets old, fast.

We completely agree. That’s why the newest update to the LMSA app introduces a feature we’ve been really excited to share with you: Templates.

Here is a quick look at how it works and how it can save you a ton of time.

What are Templates?

Think of the new Template feature as a contact book, but for your AI personalities. Instead of starting from scratch with a blank slate every time, you can now save your favorite system prompts and switch between them with just a tap.

Whether you need a quick editor for your emails or a specific character for creative writing, you can now tell your local AI exactly how to behave and save those instructions for later.

🎭 Grab a Preset and Go

If you don't want to write your own prompts right away, we’ve included a handful of built-in presets. We designed these around the most common ways people are using local AI:

• The Coding Assistant: No fluff, no long-winded explanations—just clean, debugged code.

• The Creative Brainstormer: A more expansive, imaginative persona perfect for bouncing ideas around.

• The Tutor: A patient guide designed to explain complex topics simply, step-by-step.

🛠️ Build Your Own Custom Personas

If you like to tinker, the Custom Persona builder is where the real fun happens. You can create an AI exactly tailored to your workflow:

• Give it an identity: Name your persona and give it a quick description so it's easy to find in your library.

• Write the rules: Set the exact system prompt dictating the AI's tone, formatting, and boundaries.

• Set the stage: Create a custom first message so the AI always greets you exactly how you want it to.

Why We Think You'll Love It

We built this because context-switching on mobile should be frictionless. You shouldn't have to fight your phone's keyboard just to change what your AI is doing.

By locking in your custom personas, your favorite models (like Llama 3 or Mistral) will behave consistently across all your conversations. Plus, we added the ability to import and export your templates as JSON files. This makes it super easy to back up your hard-earned system prompts or share your coolest personas with the community.

How to Try It Out

Getting started is easy. Just make sure you've updated to the latest version of the LMSA app on the Google Play Store.

1. Open the app and head to the new Templates section.

2. Browse the presets or tap the "+" icon to draft your own custom persona.

3. Select your template and start chatting!

We’re really proud of how the LMSA app is shaping up, and this feature is a big step in making mobile local AI feel more native, personalized, and easy to use.

You can grab the latest update on the Google Play Store, or learn more over at lmsa.app.

Ray’s Tech Journal readers have seen plenty of “incremental” AI updates lately—this one is notable because it focuses on controllable reasoning depth and practical ergonomics (context size, output limits, multimodal inputs) that directly affect real projects.

What’s new in Gemini Pro 3.1

The headline feature is a configurable thinking system often described as “3-level thinking,” where you can choose how much cognitive effort the model should spend on a task. In plain terms: you can trade speed for deeper reasoning when you need it, instead of always paying the latency/compute cost of maximum deliberation.

In addition, Gemini Pro 3.1 is being marketed as a stronger “agentic” model—better at planning, following multi-step instructions, and staying coherent across longer tool-using workflows (coding, analysis, document synthesis, and task automation).

Reasoning upgrades that matter

Most modern models can write well; the difference shows up when you ask them to do things like: debug a real codebase, reconcile contradictions across multiple documents, or solve problems that require careful multi-step logic.

With Gemini Pro 3.1, Google is emphasizing improved performance on reasoning-heavy evaluations (including ARC-style abstract reasoning and graduate-level QA benchmarks). Treat benchmark numbers as directional—useful for judging relative progress—but still validate with your own workload, because real-world tasks (your data, your domain, your constraints) are where wins or regressions show up.

Bigger context + multimodal by default

Gemini Pro 3.1 is associated with a very large context window (commonly reported at up to 1 million tokens). That translates into more reliable work on:

• Long documents (contracts, specs, research PDFs, policy manuals).

• Large repositories (multiple files, cross-references, architectural context).

• “Threaded” conversations where earlier constraints must remain active.

It’s also presented as natively multimodal—designed to reason across text and other modalities in one flow—so you can do things like discuss a screenshot, summarize a slide deck, or analyze a diagram without awkward, separate “OCR then interpret” steps.

Developer access, output limits, and pricing (what to watch)

If you’re integrating Gemini Pro 3.1 into products, the practical questions are: cost, latency, output length, and reliability under load.

At the time of writing, widely reported API pricing for Gemini Pro 3.1 is around:

• Input: $2.00 per 1M tokens

• Output: $12.00 per 1M tokens

Two other implementation details matter just as much as price:

• Long output support (often cited up to ~65K tokens per response), which helps avoid truncation when generating long reports or substantial code.

• Large upload limits (commonly reported up to ~100MB per prompt in some contexts), which makes “bring your own data” workflows smoother.

Before you commit, confirm the exact limits and pricing in the current developer console/docs for your region and product tier—they can change, and they may differ between consumer subscriptions and developer API usage.

Where Gemini Pro 3.1 fits best (and a quick reality check)

Gemini Pro 3.1 looks like a strong fit when you need one or more of the following:

• Deep reasoning on messy, real-world inputs (requirements docs, bug reports, logs).

• Long-context synthesis (multi-document comparisons, compliance mapping, research review).

• Multimodal analysis (images/diagrams + text in a single workflow).

• More control over speed vs. reasoning depth (fast drafts vs. careful final answers).

Reality check: even “Pro” models can still hallucinate, misread ambiguous prompts, or miss edge cases. If accuracy matters, design your workflow with guardrails—grounding on source text, explicit constraints, verification steps, and tests (for code) rather than trusting any single pass.

If you want, I can tailor this post to your audience (developer-heavy vs. general tech readers) and add a short “How I’d test it” section with 5 concrete prompts you can run to evaluate Gemini Pro 3.1 against the model you use today.

Landing just five months after the highly regarded Sonnet 4.5, version 4.6 isn't just "smarter." It represents a deliberate pivot toward reliable, autonomous agents. While the industry chases ever-higher raw intelligence scores, Sonnet 4.6 focuses on the ability to execute complex, multi-step tasks—specifically coding and computer operation—without going off the rails.

For developers and enterprise architects, the headline is simple: Sonnet 4.6 delivers near-flagship performance at the existing mid-tier price point ($3/1M input, $15/1M output).

Here is a comprehensive review into what’s new, the benchmark data, and where Sonnet 4.6 lands in the brutal landscape of 2026 AI.

The Core Upgrades: Context and Agency

Sonnet 4.5 was excellent at understanding instructions. Sonnet 4.6 is designed to execute them autonomously. Two major technical shifts define this release:

1. The 1 Million Token Context Window (Beta)

The jump from 4.5’s 200K context to 4.6’s 1M tokens is significant. While Gemini still holds the absolute crown for massive retrieval, 1M tokens moves Sonnet out of the "large document" category and into the "entire repository" category. This isn't just about reading more; it’s about maintaining coherent reasoning capability over extremely long-horizon tasks without suffering from the "forgetfulness" that plagued earlier models near their context limits.

2. "Computer Use" Maturity

Anthropic’s "Computer Use" API—allowing the model to control a mouse and keyboard to navigate standard GUIs—was experimental in 4.5. In 4.6, it’s production-ready. The model has significantly improved its ability to recover from errors when navigating web interfaces, making it viable for automating complex back-office workflows that lack traditional APIs.

The Family Feud: Sonnet 4.6 vs. 4.5

If you are currently running Sonnet 4.5 in production, the upgrade to 4.6 is essentially a no-brainer drop-in replacement due to price parity. But the performance gains are heavily weighted toward active tasks rather than passive knowledge retrieval.

The benchmarks show a clear trend: the harder and more "active" the task, the bigger the improvement.

The takeaway: The 9-point jump in HumanEval is the standout statistic. Anthropic suggests this is due to improved "recursive reasoning"—the model's ability to plan out code structure before committing to token generation, rather than just pattern-matching the next line.

The Competitive Landscape: GPT-5 and Gemini 3

Sonnet 4.6 has effectively collapsed the traditional "mid-tier." It is now performing at a level that challenges the flagship models of early 2026, though different models still dominate specific niches.

vs. OpenAI GPT-5

GPT-5 remains the raw intelligence champion. On pure reasoning tasks (like GPQA Diamond) and generative coding (HumanEval), GPT-5 still edges out Sonnet 4.6 (GPT-5 scores ~94% on HumanEval vs Sonnet's 91%).

However, this edge comes at a premium—GPT-5 costs roughly 3x more per token. For high-volume applications, Sonnet 4.6 provides a much better ratio of performance to cost. Furthermore, Sonnet 4.6 is currently beating GPT-5 on the OSWorld benchmark, making Claude the preferred choice for browser automation agents.

vs. Google Gemini 3 Pro

The battle with Google is nuanced. Gemini 3 Pro retains the title of "Context King" with its 2M+ native window.

Pricing is the real battleground here. Gemini 3 Pro employs a tiered structure. For short-context tasks (<200K tokens), Gemini is actually cheaper than Sonnet 4.6. However, once you cross that threshold into "long-context" territory, Google's price doubles, making Sonnet 4.6's flat-rate pricing significantly more economical for heavy-duty data processing.

The Verdict

Claude Sonnet 4.6 is a pragmatic, highly potent release. It doesn't try to win every single benchmark through brute force scale. Instead, it targets the specific bottlenecks holding back autonomous AI development: reliability in coding and stability in using GUI tools.

For developers building the next generation of AI agents that need to code, browse, and reason over massive amounts of data without breaking the bank, Sonnet 4.6 is the new standard bearer.

Let's talk about a simple solution that can make your coding experience smoother and more efficient: modularizing your code.

What Is Modularizing Code?

Think of modularizing code like organizing a messy bedroom. Instead of throwing everything into one giant pile in the corner, you separate items into different drawers and containers. Socks go in one drawer, shirts in another, books on a shelf, and electronics in a charging station. When you need something specific, you know exactly where to look instead of digging through the entire pile. You save time, reduce frustration, and can find what you need in seconds rather than minutes.

In programming, modularizing means breaking up your code into smaller, separate files where each file has a specific purpose or handles a particular feature of your application. Instead of having one massive 5,000-line file that handles your entire application, you might have:

• A file for user login and authentication

• A file for displaying your homepage

• A file for processing payments

• A file for sending emails

• A file for managing your database connections

• A file for handling user profiles

• A file for generating reports

Each piece lives in its own space, focused on doing one thing well. This organization principle is sometimes called "separation of concerns," which simply means keeping different responsibilities in different places.

The Real Problem with Large Files

Before we dive into the benefits, let's understand what actually happens when your code files grow too large.

Imagine you have a single file with 4,000 lines of code that handles everything in your web application: user logins, displaying products, processing orders, sending confirmation emails, and generating reports. When you ask your AI assistant to make a simple change like updating the color of a button on your homepage, here's what happens behind the scenes:

The AI must first read and analyze all 4,000 lines to understand the context of your project. It needs to figure out where the homepage code is located, what other parts of the code might be affected by the change, and how everything connects together. This process consumes significant computational resources and uses up your API quota with the AI service.

Now multiply this by every single change you make throughout your development process. If you're making 50 small tweaks and updates in a day, your AI is processing hundreds of thousands of lines of code repeatedly, most of which aren't even relevant to the changes you're making.

Why This Matters When You're Using AI Coders

When you ask your AI coding assistant to make a change, the AI needs to search through your code files to understand the context and make the right modifications. Here's where file size becomes a major issue, and why modularization can transform your development experience.

You'll Stop Hitting Rate Limits So Quickly

This is perhaps the biggest benefit for anyone using agentic coders. Most AI coding services have rate limits, which are restrictions on how many requests you can make or how much data you can process in a given time period. These limits exist to manage server load and ensure fair access for all users.

When your AI assistant needs to analyze a 3,000-line file just to change a button color, it's processing enormous amounts of code for a tiny task. Think about it: if the button styling code is just 10 lines buried somewhere in that massive file, the AI still needs to read and understand all 3,000 lines to locate it and ensure the change won't break anything else.

With modularized code, your AI only needs to look at the relevant 200-line file instead of the entire 3,000-line behemoth. This means:

• Each request uses less of your rate limit allowance because less data is being processed

• You can make more changes before hitting limits, allowing you to be more productive

• Your AI responds faster since it has less code to analyze and understand

• You save money if you're on a usage-based pricing plan where you pay per token or request

• You avoid the frustration of waiting when you hit your limit mid-project

• You can work on more complex features without worrying about exhausting your quota

For example, if your rate limit allows you to process 1 million tokens per day, and each change requires analyzing 3,000 lines of code (roughly 100,000 tokens), you can only make about 10 changes before hitting your limit. But if you modularize and each change only requires analyzing 200 lines (roughly 7,000 tokens), you could make over 140 changes in the same period. That's a 14x improvement in productivity.

Your AI Makes Fewer Mistakes

When an AI assistant has to search through thousands of lines of code, it's easier for it to get confused, miss important context, or make incorrect assumptions about how different parts of your code interact. Large files often contain multiple related but distinct features, and the AI might accidentally modify the wrong section or fail to recognize important dependencies.

Smaller, focused files mean your AI can better understand what each piece of code does. When a file is dedicated to just one feature or component, the AI can maintain better context awareness throughout the modification process. This leads to more accurate suggestions, fewer bugs introduced into your project, and less time spent fixing issues that shouldn't have occurred in the first place.

Consider this scenario: you want to update how error messages are displayed to users. In a monolithic 4,000-line file, error handling code might be scattered throughout, mixed with business logic, database queries, and user interface code. Your AI might update one error message but miss others, or accidentally change error handling in a critical security function. In a modularized structure, all error handling would be centralized in its own file, making it crystal clear what needs to be updated and reducing the risk of unintended consequences.

Changes Happen Faster

Speed matters when you're building and iterating on a project. Instead of waiting for your AI to process a massive file, it can quickly scan a smaller module and get to work immediately. What might have taken 30 seconds to analyze now takes 5 seconds. Multiply that across dozens or hundreds of changes throughout your development process, and you're saving hours of cumulative waiting time.

This speed improvement isn't just about the initial analysis either. When your AI generates code changes, it can be more precise and focused because it's working within a well-defined scope. You'll spend less time reviewing sprawling diffs that touch multiple unrelated sections of code and more time actually building features.

Your Project Becomes More Maintainable

Even though you're using AI to code, you still need to understand your project at a high level. When someone asks "How does the payment processing work in your app?" you should be able to explain it conceptually, even if you didn't write the code yourself.

When code is organized into clear modules, both you and your AI assistant can navigate the project more intuitively. Need to update the payment processing? You know exactly which file to point your AI toward. Want to modify how emails are sent? There's a dedicated email module for that. This clarity becomes increasingly valuable as your project grows and you need to make updates months or even years after the initial development.

Modular code also makes it easier to:

• Onboard other people to your project if you decide to collaborate

• Understand what your application actually does without reading every line

• Debug issues because problems are isolated to specific modules

• Upgrade or replace individual components without affecting the entire system

• Test different parts of your application independently

Better Collaboration with Your AI

When you work with modular code, your conversations with your AI assistant become more focused and productive. Instead of vague requests like "update the user system," you can be specific: "modify the user-authentication.js file to add two-factor authentication." The AI immediately knows where to look and what scope of work is involved.

This specificity reduces back-and-forth clarification questions, makes your instructions clearer, and helps the AI provide more relevant suggestions. You're essentially speaking the same organizational language as your codebase.

Easier to Reuse and Repurpose Code

When code is modularized properly, individual modules can often be reused in other projects or repurposed for different features. That email-sending module you created for one project? It might work perfectly in your next project with minimal modifications. Your AI can more easily adapt and transplant modular code because each piece is self-contained with clear inputs and outputs.

Understanding Different Types of Modules

While you don't need to know the technical details, it helps to understand the common ways code gets modularized:

Feature-Based Modules: Each module represents a complete feature of your application. For example, everything related to user accounts (registration, login, profile management, password reset) lives together in an accounts module.

Layer-Based Modules: Code is separated by its role in the application architecture. You might have modules for handling user interface elements, modules for business logic, and modules for database interactions.

Shared Utility Modules: Common functions that multiple parts of your application need (like formatting dates, validating email addresses, or generating random IDs) live in shared utility modules that other modules can use.

Your AI assistant can help you determine which organizational approach makes the most sense for your specific project.

How to Think About Modularizing

You don't need to understand code to start thinking modularly. When working with your AI assistant, you can simply ask it to organize your project more effectively. Here are some ways to communicate what you want:

• "Split this file into smaller, focused files based on what each section does"

• "Organize this code so related functions are grouped together in separate files"

• "Break up this large file into modules, where each module handles one specific feature"

• "Refactor this project to follow best practices for code organization"

• "Create a more modular structure for this application"

Your AI coding assistant will understand what you mean and can handle the technical implementation. Most modern AI assistants are quite good at identifying logical boundaries in code and suggesting appropriate module divisions.

Signs Your Project Needs Modularization

How do you know when it's time to modularize? Look for these warning signs:

• Individual files are over 500-1,000 lines long

• You're hitting rate limits frequently during development sessions

• Your AI takes noticeably longer to respond to change requests

• You find it hard to explain what's in a particular file because it does "many things"

• Making a small change often requires your AI to modify multiple scattered sections of code

• You're experiencing more bugs and unexpected behavior after changes

• You're hesitant to make changes because you're not sure what else might break

If any of these resonate with your experience, modularization will likely provide significant benefits.

Getting Started with Modularization

If you're working on a project with large files, here's a practical approach to begin modularizing:

Step 1: Assessment
Ask your AI assistant to analyze your project and identify the largest files. You might say: "Please review my project and tell me which files are the largest and what they contain."

Step 2: Identify Boundaries
Request that your AI identify logical sections that could be separated. For example: "Look at this 3,000-line file and suggest how it could be broken into smaller, focused modules."

Step 3: Create a Plan
Have your AI create a detailed reorganization plan before making any changes. This should include what new files will be created, what code will move where, and how the modules will connect to each other. You want to review and understand this plan before implementation.

Step 4: Implement Gradually
Don't try to reorganize everything at once. Start with one large file or one section of your project. Have your AI implement the changes, then test thoroughly to make sure everything still works correctly. Once you're confident in the process, continue with other areas.

Step 5: Test as You Go
After each modularization step, test your application to ensure nothing broke. Ask your AI to run any tests and verify functionality. This incremental approach means if something does go wrong, you know exactly what change caused it.

Step 6: Document the Structure
Once you've modularized, ask your AI to create documentation explaining the new file structure and what each module does. This helps you understand your own project better and makes future changes easier.

Best Practices to Follow

As you work on modularizing your code with your AI assistant, keep these principles in mind:

Keep Related Things Together: Code that works together should live together. If five different functions all deal with processing payments, they should be in the same payment-processing module.

Avoid Duplication: If the same code appears in multiple modules, ask your AI to create a shared utility module for it. This makes your codebase smaller and easier to maintain.

Use Clear, Descriptive Names: Module names should clearly indicate what they contain. Names like "user-authentication.js" or "payment-processor.py" tell you exactly what to expect inside.

Start with Bigger Chunks: Don't over-modularize initially. It's better to have 10 well-organized modules of 300 lines each than 100 tiny modules of 30 lines each. You can always split further if needed.

Maintain Consistency: Use the same organizational approach throughout your project. If you're organizing by features in one area, continue that pattern in other areas.

The Long-Term Benefits

The upfront investment of reorganizing will pay dividends throughout the life of your project:

• Faster development cycles as your AI works more efficiently

• Lower costs if you're paying per API request or token usage

• Fewer frustrating debugging sessions caused by unclear code organization

• Easier feature additions because you know exactly where new code should live

• Better ability to understand and explain your own project

• Smoother experience when you need to update or maintain code months later

Think of modularization as preventive maintenance. Just like regular car maintenance prevents bigger problems down the road, organizing your code now prevents headaches later.

Real-World Impact

Let's look at a concrete example. Suppose you're building a task management application and started with everything in a single file. As you add features, that file grows to 4,500 lines. Now you want to add a feature to export tasks to a spreadsheet.

Without modularization: Your AI needs to analyze all 4,500 lines to understand the task structure, find where tasks are stored and retrieved, figure out data formatting, and determine where to add the export functionality. This might take 30-45 seconds per request, consume significant API tokens, and potentially require multiple iterations as the AI navigates the complex file. You might hit your rate limit after 8-10 such changes.

With modularization: Your tasks are in a task-module.js file (200 lines), data formatting is in utilities.js (150 lines), and there's a clear exports folder for adding new export types. Your AI quickly analyzes just the relevant files, understands the task structure immediately, and can implement the feature in 5-10 seconds per request. You can make 40-50 changes before hitting rate limits, and the implementation is cleaner because the code boundaries are clear.

The difference isn't just quantitative; it's qualitative. Modular code makes development feel smoother and more intuitive.

Moving Forward

Remember, good organization isn't just for human programmers. It's just as valuable, if not more so, when you're working with AI assistants. By keeping your files manageable and focused, you're setting both yourself and your AI up for success.

The beauty of using AI coding assistants is that they can help you modularize even if you don't understand the code itself. You provide the high-level direction, and your AI handles the technical implementation. This makes proper code organization accessible to everyone, regardless of programming knowledge.

Start small, be consistent, and watch how much more efficiently you can work when your code is properly organized. Your future self, and your AI assistant, will thank you.

In this guide, we will break down exactly which models you should be loading into LM Studio right now. Whether you are a developer needing a coding copilot, a writer looking for a creative spark, or a privacy-conscious user who wants a general assistant, there is a model optimized for your specific hardware.

The State of Local AI in 2026

Before we dive into the models, it is crucial to understand why 2026 is different. The "Size vs. Intelligence" curve has been bent. Two years ago, you needed 70 billion parameters to get GPT-4 class performance. Today, thanks to heavy optimizations in MoE (Mixture of Experts) and distillation techniques, models in the 8B-14B range are outperforming the giants of 2024.

LM Studio has also evolved. With native support for multimodal inputs (text + image) and improved GPU offloading for Apple Silicon (M4 chips specifically) and NVIDIA 50-series cards, the barrier to entry is lower than ever.

1. The Coding Kings: "Copilot" Killers

If you are a developer, 2026 is the year you can finally disconnect from the cloud without losing IQ points. The "Qwen vs. DeepSeek" rivalry has produced models that genuinely understand system architecture, not just syntax.

The New Champion: Qwen 3 Coder (32B & 480B MoE)

• Best For: Production-level coding, refactoring legacy code, and polyglot development.

• Hardware: 24GB VRAM (32B Q4) or dual-GPU setups (480B MoE).

Forget Qwen 2.5. The Qwen 3 Coder series, released fully in late 2025, is the current undisputed king of local development. The 32B parameter version is the sweet spot for high-end consumer GPUs (like the RTX 4090 or 5090).

Unlike its predecessors, Qwen 3 Coder doesn't just autocomplete; it understands "repo-level" context. It features a native 256k context window that actually works, allowing you to feed it entire documentation libraries. In benchmarks, the 32B model is consistently beating the proprietary giants of 2024 (like GPT-4o) in Python and Rust tasks. If you have the hardware, this is the only model you need.

The "Thinking" Coder: DeepSeek R1 (Distilled)

• Best For: Debugging "impossible" errors and algorithmic logic.

• Hardware: Varied (Distills exist from 7B to 70B).

DeepSeek R1 changed the game by introducing "Chain of Thought" (CoT) as a native behavior. It pauses to "think" (outputting internal monologue) before writing code. This makes it slower than Qwen but significantly more accurate for complex logic puzzles or hunting down race conditions.

The Lightweight: Qwen 3 Coder (7B/14B)

• Best For: VS Code autocompletion and background chat.

• Hardware: 8GB - 12GB VRAM.

For those without massive VRAM, the 14B version of Qwen 3 Coder is a miracle. It retains the architectural smarts of its big brother but fits on a standard gaming card. It is snappy, follows instructions perfectly, and has replaced the "CodeLlama" lineage entirely.

2. The General Assistants: Your Daily Drivers

These models are your "Swiss Army Knives." They handle email, summarization, creative brainstorming, and general questions.

The Dual-Mode Genius: Qwen 3 (14B & 32B)

• Best For: Everything. Literally.

• Hardware: 12GB - 24GB VRAM.

The latest Qwen 3 release introduced a paradigm shift: the ability to toggle between Thinking Mode (for complex reasoning/math) and Non-Thinking Mode (for fast chat) within the same model.

In LM Studio, this makes it arguably the most versatile model available. You can have it quickly draft an email (Non-Thinking) and then immediately ask it to solve a logic puzzle (Thinking), and it handles both with state-of-the-art performance. It has effectively killed the need to switch models for different tasks.

The Reliable Standard: Llama 4 (8B)

• Best For: RAG (Chat with documents), strict instruction following, and roleplay.

• Hardware: 8GB VRAM.

Meta’s Llama 4 remains the baseline for stability. While Qwen might be "smarter" in raw logic, Llama 4 8B is incredibly "steerable." It refuses fewer prompts than Llama 3 and adheres strictly to system prompts. If you are building a specific persona in LM Studio or using the "Chat with Docs" feature, Llama 4 is often less prone to going off-topic than the more creative models.

3. The Storytellers: Creative Writing & Roleplay

Creative writing requires a different kind of intelligence—high entropy, stylistic nuance, and a lack of "moralizing" refusal. The coding models above are often too dry for this.

The Artist: Magnum v4 (72B & 12B)

• Best For: Novel writing, prose, and nuanced roleplay.

• Hardware: 12GB (12B) to 48GB (72B).

The community has spoken: Magnum v4 (a heavy finetune of Qwen/Llama architectures) is the current gold standard for prose. Unlike base models that sound robotic, Magnum is tuned on high-quality literature and roleplay data. It understands "Show, Don't Tell," handles mature themes without lecturing, and maintains long-term narrative consistency.

The European Wit: Ministral 3 (and Mistral Small 3)

• Best For: Witty dialogue, screenplays, and non-cliché writing.

• Hardware: Extremely low (4GB - 8GB VRAM).

Mistral AI continues to dominate the "efficiency" bracket. Ministral 3 is designed specifically for edge devices. It has a distinct "personality"—dry, concise, and smart—that contrasts with the overly enthusiastic "Customer Service AI" vibe of American models. If you want a character that sounds cynical or witty, Ministral is your best choice.

4. The Laptop Class: Running AI on "Potatoes"

You don't have an NVIDIA GPU? No problem. 2026 is the year of the "Small Language Model" (SLM).

The Miracle: Phi-4 (Microsoft)

• Specs: ~4B Parameters.

• Hardware: Runs on almost any modern laptop CPU/RAM.

Microsoft’s Phi-4 defies the laws of physics. Trained on synthetic "textbook" data, it reasons better than old 13B models while being small enough to run alongside your web browser. It is perfect for summarization and quick questions.

The Edge King: Ministral 3

• Specs: ~3B-8B Parameters.

• Hardware: 4GB VRAM or Apple Silicon (M1/M2/M3).

As mentioned above, Ministral 3 is the first "frontier-class" model designed to run on a phone or basic laptop. It supports a massive context window for its size, meaning you can load a whole book into it on a MacBook Air and chat with it locally.

5. Technical Guide: How to Choose in LM Studio

Understanding Quantization (The "Q" Numbers)

When you search for these models in LM Studio, you will see filenames like Llama-4-8B-Q4_K_M.gguf.

• Q4 (4-bit): The industry standard. It compresses the model to use less memory with almost zero loss in intelligence. Pick this one.

• Q8 (8-bit): Higher precision, but double the memory usage. Rarely worth it for local use.

• Q2/Q3 (2-3 bit): Only use if you are desperate for RAM. The model will become noticeably "dumber."

VRAM Cheatsheet for 2026

• 8GB VRAM: Stick to 8B models (Llama 4, Mistral) at Q4/Q5 quantization.

• 12GB VRAM: You can run 12B-14B models (Mistral NeMo, Phi-4 Medium) comfortably.

• 16GB VRAM: You can stretch to 20B-30B models or run 8B models with massive context (long document analysis).

• 24GB VRAM (RTX 3090/4090/5090): You are in the 70B territory. You can run Qwen 72B or Llama 4 70B at low quantization (Q2/Q3) or highly compressed formats like EXL2.

Bonus: How to Use LM Studio from Your Couch (Android)

One of the biggest misconceptions about local AI is that you have to be tethered to your desktop to use it. In 2026, that is no longer the case. If you want to chat with DeepSeek R1 or Llama 4 while cooking dinner or relaxing in the living room, you can bridge your powerful PC to your phone using LMSA.

LMSA (LM Studio Assistant) is a dedicated Android client that connects strictly over your local Wi-Fi network, preserving the privacy benefits of local AI while giving you the flexibility of a mobile app.

Why Use LMSA?

Unlike generic "remote desktop" solutions, this app is purpose-built for LM Studio.

• Native Model Switching: You don't need to run back to your computer to swap from a coding model to a creative writing one; you can switch loaded models directly from the app interface.

• Thinking Mode Support: Perfect for the new 2026 reasoning models, LMSA lets you see the model's internal "thought process" before it generates a final reply.

• Prompt Library: You can save your favorite system prompts (e.g., "Python Expert" or "Creative Editor") on your phone and apply them instantly to new chats.

Quick Setup Guide

1. Prep Your PC: Open LM Studio on your computer, navigate to the Developer/Server tab, and click "Start Server" (usually on port 1234).

2. Connect: Ensure your Android phone and PC are on the same Wi-Fi network.

3. Configure App: Open LMSA, enter your computer’s local IP address (displayed in LM Studio), and start chatting.

You can download LMSA directly from the Google Play Store here:
Get LMSA: AI Chat with LM Studio

Summary Cheatsheet (January 2026)

A Final Note on LM Studio Settings

To get the most out of these 2026 models, ensure you tweak your LM Studio settings:

1. Context Length: Set Qwen 3 and Llama 4 to at least 16,384. They can handle it.

2. Flash Attention: Enable this in the "Model Settings" sidebar. It is mandatory for reasonable speeds on the new Qwen and DeepSeek architectures.

3. Temperature:

   • Use 0.0 - 0.3 for Coding (Qwen 3 Coder).

   • Use 0.8 - 1.1 for Creative Writing (Magnum/Mistral).

The hardware barrier has fallen. Whether you are rocking an RTX 5090 or a MacBook Air, there is a model released in the last 6 months that will change how you work. Go download Qwen 3 Coder or Ministral 3 right now and see for yourself.

Enter Google Antigravity.

Released in late 2025, Antigravity has quickly become the buzzword in tech circles. While it is technically a fork of VS Code, dismissing it as "just another reskin" would be a massive mistake. Antigravity takes the familiar foundation of VS Code and bolts on a production-grade Agent Manager and enterprise-level Secure Mode that transform it from a code editor into a "coding factory."

In this post, we’ll break down exactly what Antigravity is, why its relationship to VS Code matters, how to master the Agent Manager with real-world examples, and why its security features make it the only viable choice for the modern "Agentic" workflow.

The Familiar Foundation: Yes, It’s a Fork

The first thing you’ll notice when you open Antigravity is that it feels like home. That’s because, at its core, it is built on the open-source Electron architecture of VS Code.

Why Being a Fork Matters

For years, switching IDEs meant relearning muscle memory. You had to learn new hotkeys, find equivalent plugins, and get used to a new UI layout. Because Antigravity is a fork, you don't have to do any of that.

• Same Shortcuts: Ctrl+P (or Cmd+P) still opens the file palette. Ctrl+Shift+F still searches your project.

• Extension Compatibility: It supports the vast ecosystem of extensions you rely on. By default, it connects to the OpenVSX registry, but you can even configure it to pull from the official VS Code Marketplace if you prefer specific proprietary extensions.

This "fork" status is Google's trojan horse. They didn't try to reinvent the wheel; they just put a rocket engine on the car everyone was already driving. You get the comfort of VS Code with the power of Google's Gemini-backed infrastructure.

The Game Changer: The Agent Manager

This is where Antigravity leaves standard VS Code in the dust. In a traditional IDE—even one with Copilot or Cursor—you are the pilot. You type, and the AI suggests completions or answers chat questions. It’s a passive, linear relationship.

Antigravity introduces the Agent Manager, a feature that fundamentally changes your role from "writer of code" to "manager of agents."

Orchestration vs. Autocomplete

When you launch Antigravity, you aren't just greeted by a file tree. You see the Manager View (often called "Mission Control"). This dashboard allows you to spawn, monitor, and interact with multiple agents operating asynchronously.

• Autonomous Execution: The agent doesn't just write code; it plans the steps. It has access to the terminal, the editor, and a browser. It can install dependencies, run tests, read documentation, and debug its own errors.

• Artifacts: Instead of just dumping code into your file, the Agent produces "Artifacts"—structured plans, screenshots of the app running, and logs. You review these artifacts just like a manager reviews a report from a junior developer.

Parallel Workflows

The Agent Manager allows you to spin up multiple agents. You can have one agent fixing a bug in the backend while another agent updates the CSS in the frontend. You watch their progress in the Manager View, intervening only when they get stuck or need approval. This parallelism is simply impossible in standard VS Code without a messy clutter of external tools.

How to Use the Agent Manager: Real-World Scenarios

To truly understand the power of Antigravity, we need to move past theory. Here are three concrete examples of how you can use the Agent Manager to accelerate your development workflow today.

Scenario 1: The "Greenfield" Project (Building from Scratch)

Imagine you have an idea for a simple "Task Manager" app using React and Firebase.

The Old Way (VS Code):
You run npx create-react-app, delete the boilerplate files, manually set up your folder structure, install Firebase SDKs, create your firebase.js config, and then start coding your components one by one.

The Antigravity Way:

1. Open Agent Manager: Click the "Mission Control" icon in the sidebar.

2. Define the Objective: In the prompt box, type: "Create a new React application for a Task Manager. It needs a sidebar, a main task list, and a Firebase configuration file. Use Tailwind CSS for styling."

3. Review the Plan: The Agent will switch to Planning Mode. It will generate a textual plan listing the files it intends to create (e.g., src/components/Sidebar.jsx, src/firebase.js).

4. Approve and Execute: You click "Approve." The agent opens a terminal instance, runs the scaffolding commands, installs Tailwind, and creates the files.

5. Iterate: You see the "Artifact" (a screenshot of the rendered app) in the dashboard. You notice the sidebar is blue, but you wanted it dark mode. You type: "Make the sidebar dark grey." The agent edits the CSS autonomously.

Why it’s better: You saved 45 minutes of boilerplate setup. You acted as the Architect, not the Typist.

Scenario 2: The "Legacy Refactor" (Modernizing Code)

You have an old JavaScript utility file (utils.js) written in ES5 with var and callback functions. You want to modernize it to TypeScript and ES6 async/await.

The Old Way:
You open the file and manually rewrite every function. You copy-paste types. You accidentally break a function and spend 20 minutes debugging.

The Antigravity Way:

1. Spawn a "Refactor" Agent: In the Agent Manager, select the utils.js file and type: "Refactor this file to TypeScript. Convert all callbacks to async/await promises. Add JSDoc comments."

2. Parallel Execution: While that agent works, you can go to a different file and continue your own coding. The agent works in the background.

3. Review Changes: The agent pings you with a "Request Review." You see a diff view of the changes. It has correctly typed the variables and converted the syntax.

4. Test Verification: You ask the agent: "Run the existing unit tests to make sure nothing broke." The agent runs npm test in its terminal context. If a test fails, it self-corrects the code and re-runs the test until it passes.

Why it’s better: Refactoring is tedious and error-prone. The Agent handles the grunt work while you ensure the logic remains sound.

Scenario 3: The "Bug Hunt" (Self-Healing Code)

You are working on a Python backend and suddenly hit a cryptic 500 Internal Server Error.

The Old Way:
You stare at the terminal logs. You copy the error message. You paste it into Google or ChatGPT. You try the solution. It fails. You try again.

The Antigravity Way:

1. One-Click Debug: You highlight the error in your terminal and click "Fix with Agent."

2. Root Cause Analysis: The agent analyzes the stack trace. It reads the relevant file (views.py). It notices you accessed a dictionary key that doesn't exist.

3. Browser Verification: Unsure of the correct API response format, the agent autonomously opens a browser instance, navigates to the API documentation (e.g., Stripe or Twilio docs), and verifies the correct key name.

4. The Fix: It proposes a code change: data.get('id') instead of data['id']. You accept, and the server restarts automatically.

Why it’s better: The agent has context. It can "read" your code and "browse" the web simultaneously to solve the problem, rather than just guessing based on the error message alone.

Security: The Invisible Moat

The terrifying part of "Agentic AI" is giving an AI access to your terminal. In late 2025, a developer famously had their entire D: drive wiped because an agent autonomously ran a delete command.

To solve this, Google introduced Secure Mode, a feature that makes Antigravity significantly safer than running agentic tools in VS Code.

How "Secure Mode" Works

Secure Mode acts as a strict supervisor for your AI agent. In VS Code extensions, agents often run with full permission or require you to manually approve every single tiny action, which is annoying. Secure Mode finds the balance:

• The Guard Rails: When enabled, Secure Mode restricts the agent's access to external resources and sensitive operations. It prevents the agent from stepping outside the bounds of your specific project folder, ensuring it can't accidentally touch system files or other drives.

• Terminal Policy: Unlike "Turbo Mode" (where the agent runs any command it wants), Secure Mode enforces a "Request Review" policy for high-risk commands. If the agent wants to run npm test, it might proceed. If it tries to run rm -rf, it is blocked until you explicitly say yes.

• Browser Isolation: Agents often need to browse the web to read documentation. Secure Mode can restrict this access using a "URL Allowlist," preventing the agent from visiting compromised sites that might contain "prompt injection" attacks designed to hijack the AI.

By baking these controls directly into the IDE rather than relying on a third-party plugin, Antigravity ensures that you can use autonomous agents without the fear of waking up to a deleted hard drive.

Comparison: Antigravity vs. The Rest

Antigravity isn't the only player in the AI IDE space. Its main competitors are Cursor and Windsurf. Here is how they stack up.

Cursor

• Pros: The "OG" AI editor. Extremely polished autocomplete. Good "Composer" feature for multi-file edits.

• Cons: Still feels like "Chat + Editor." Lacks the robust autonomous agent management of Antigravity. You are still very much the driver.

Windsurf (Codeium)

• Pros: Excellent "Cascade" flow that contextually understands your codebase. Very fast.

• Cons: The agent capabilities are newer and less proven than Google's massive Gemini backend.

Google Antigravity

• The Winner For: Orchestration. If you want to manage multiple streams of work—one agent testing, one agent documenting, one agent coding—Antigravity is the only tool built for this "Squad Vibe."

• The Winner For: Ecosystem. If you use Google Cloud, Firebase, or Android, the integration is native. The "Model Armor" security layer is unmatched for enterprise users.

Conclusion: The Evolution of Coding

Google Antigravity is not just a "better VS Code." It represents the transition from the Developer Era to the Agentic Era.

By forking VS Code, Google ensured that the transition is painless. You keep your themes, your keybindings, and your extensions. But by adding the Agent Manager, they gave you a team of autonomous coding partners. And with Secure Mode, they made sure those partners don't burn down the house.

If you are still manually typing every line of code in 2026, you are working harder than you need to. It might be time to let gravity do the work.

I took seven cutting-edge LLMs: ChatGPT 5.2, Google Gemini 3 Pro, Claude 4.5 Sonnet, Grok 4.1, GLM 4.6, Kimi K2, and Qwen3 Max, and gave them all the exact same prompt:

"Build a fully functional, high-quality calculator with an impressive UI using HTML, JavaScript, and Tailwind CSS in a single HTML file. Respond with the complete working code from top to bottom."

To be sure of an even playing field, I imposed strict limitations. I disabled all "thinking modes" (chain-of-thought reasoning) and turned off web search capabilities. This forced the models to rely entirely on their internal training data and immediate generation capabilities.

There were no retries, no tweaks, and no intermediaries like Perplexity or OpenRouter, just a single shot for each model to prove its ability to produce polished, working code on demand.

Below, you’ll find the unedited results from each model, exactly as they were generated:

ChatGPT 5.2:

Google Gemini 3 Pro:

Claude 4.5 Sonnet

Grok 4.1

GLM 4.6

Kimi K2

Qwen3 Max

The Verdict?

Scan through the results, maybe copy-paste a few into your browser to see how they feel, and let me know what you think.

This guide is designed for the absolute beginner who wants to move beyond the "cloud cage" and explore the frontier of local Large Language Models (LLMs). We will cover the technical setup of LM Studio, hardware optimization strategies, the best models to use this year, and a step-by-step tutorial on connecting your Android device via the free LMSA app.

Why Choose Local AI in 2025?

Before we dive into the "how," let's talk about the "why." Why bother running your own models when ChatGPT or Claude are just a click away?

1. Absolute Privacy: When you use a cloud AI, your prompts are stored, analyzed, and often used to train future models. With LM Studio, your data stays on your hard drive. This is non-negotiable for medical, legal, or proprietary business work.

2. Zero Subscriptions: A $20/month subscription to "Pro" AI services adds up to $240 a year. Local AI is free forever once you have the hardware.

3. Uncensored & Unfiltered: Many cloud models have strict "guardrails" that can hinder creative writing or technical research. Local models allow you to choose your own level of filtering.

4. Offline Capability: Whether you're on a plane or in a dead zone, your local AI works perfectly without an internet connection.

Part 1: Setting Up the "Brain" (LM Studio)

LM Studio remains the most user-friendly gateway for local LLMs. It hides the complexity of Python environments and command-line interfaces behind a sleek, professional GUI.

Hardware Optimization: Getting the Most from Your PC

To run a model smoothly, you need to understand how your hardware interacts with the software. In 2025, the most critical factor is VRAM (Video RAM).

• The GPU Advantage: If you have an NVIDIA RTX card or an Apple Silicon Mac (M1 through M4), you are in luck. LM Studio can "offload" the model's layers to the GPU, which is significantly faster than the CPU.

• Optimization Tip: If your model feels sluggish, go to the Settings panel in LM Studio and look for GPU Offload. Crank the "GPU Layers" slider to the max. If the model is too big for your VRAM, LM Studio will automatically split the work between your GPU and system RAM.

Choosing the Right Model for 2025

Hugging Face is full of thousands of models. For a beginner, these are the current gold standards:

• Best All-Rounder: Gemma 3 It’s fast, smart, allows image upload and follows instructions perfectly.

• Best for Coding: qwen3coder. If you need help with Python or Javascript, this is the current champion.

• Best for Low-End PCs: Gemma 2 2B or Phi-3.5 Mini. These are incredibly tiny but surprisingly capable for basic chat and summarization.

Part 2: Mobile Power with LMSA (Android)

The most common complaint about local AI is that you’re "tethered" to your desk. The LMSA (Local Model Server Access) app solves this. It acts as a lightweight remote control for the AI running on your PC.

Why LMSA?

Unlike other remote apps, LMSA is purpose-built for the LM Studio ecosystem. It is free, features no subscriptions, and supports advanced features like:

• Thinking Mode: See the "thought process" of reasoning models like DeepSeek.

• In-App Model Switching: Change the model running on your PC directly from your phone.

• System Prompts: Save "personalities" (e.g., "Professional Editor" or "Fitness Coach") and swap them with one tap.

Part 3: The Step-by-Step Connection Guide

To get LMSA talking to your PC, follow these exact steps.

1. Enable the Local Server

On your computer, open LM Studio and click the Local Server icon on the left (it looks like two arrows pointing at each other).

• Select your model at the top and click Start Server.

• Crucial Step: Look for the "Server Settings" on the right. You must toggle "Cross-Origin Resource Sharing (CORS)" to ON. Without this, the Android app will be blocked for security reasons.

• Toggle "Serve on Local Network" to ON.

2. Connect the LMSA App

• Ensure your Android phone and PC are on the same Wi-Fi network.

• Open the LMSA app on your phone.

• Go to Settings and enter your PC's IP address. (To find this on Windows, type ipconfig in the Command Prompt and look for the "IPv4 Address").

• Enter the port (default is 1234). It should look like this: http://192.168.1.15:1234.

• Tap Connect. You should see the name of your loaded model appear at the top of the app.

Part 4: Pro-Tips for Advanced Users

Once you have the basics down, you can truly supercharge your setup.

Remote Access Anywhere (Tailscale)

What if you want to use your home AI while at a coffee shop? You shouldn't open your home router ports (that's a security risk). Instead, use Tailscale.

Tailscale creates a "Virtual Private Network" between your phone and your PC. Once installed on both devices, your PC will have a "Tailscale IP" (starting with 100.x.x.x). Use that IP in the LMSA app, and you can chat with your home PC from anywhere in the world over 5G.

Understanding Quantization

When downloading models, you’ll see options like Q4_K_M or Q8_0. These are "compressed" versions of the model.

• Q4_K_M: The "Goldilocks" zone. High speed, low RAM usage, and almost no loss in intelligence.

• Q8_0: High quality, but requires double the RAM. Only use this if you have a high-end workstation.

💡 Key Takeaways Box

• LM Studio is your local hub for downloading and running AI models privately.

• Hardware Matters: Use GPU Offloading to significantly speed up response times.

• LMSA is the Mobile Bridge: Use this free Android app to take your local AI on the go.

• Connectivity: Always enable CORS in LM Studio server settings to allow the phone to connect.

• Privacy First: All data stays within your local network, ensuring your prompts are never harvested.

Conclusion: The Future is Local

We are moving toward a world where every individual has a "Personal AI", a digital assistant that knows them, respects their privacy, and isn't controlled by a tech giant. By setting up LM Studio and connecting it to your Android device via LMSA, you are at the forefront of this movement.

The barrier to entry has never been lower. You don't need a PhD in Computer Science; you just need a decent PC and the right apps. Start with a small model, experiment with different system prompts in LMSA, and discover the freedom of truly private AI.

What’s Your First Model?

Are you going to start with Meta's Llama or Mistral's latest release? Let us know in the comments how your setup went!

If you were there on launch day, you know the drill. It was chaos. The traffic was insane, the servers were crying, and actually using the thing was next to impossible. But, about a week in, the dust settled. Usage stabilized, the gates opened, and I’ve been living in this editor ever since.

A lot of people have been asking if it lives up to the hype, especially with the $20/month price tag attached to the ecosystem. After a month of daily driving it, I have some thoughts.

The UI: Familiar, Yet Fortified

Right out of the box, the UI feels incredibly familiar. If you are coming from VS Code or any of its popular forks, you will feel right at home. You don’t have to relearn your workflow, which is a massive plus.

But where Google seems to be flexing its muscles isn't just in aesthetics, it’s in safety.

I noticed a suite of features in the settings that I just don’t see in other forks, specifically regarding how the AI agent interacts with your system. The standout for me is Secure Mode. When enabled, this enforces strict settings that prevent the agent from autonomously running targeted exploits and requires human review for critical actions.

Why does this matter? I’m a bit weird,I like to watch the "agentic thinking" process. I like reading the logs as the AI talks to itself. A while back, I was using a cheaper, budget-tier agent (not Antigravity) for a CLI task. It got stuck on a bug and I saw it think: "Let me check the recycle bin to see if there are any files that could be causing the problem."

Excuse me? Why does an AI need to dig through my trash to fix a coding error in my Documents folder? That kind of unprompted behavior is terrifying. With Antigravity’s Secure Mode, I don't have that anxiety. I know it’s not going to "proceed and look the other way."

The "Restore" Feature That Actually Works

We need to talk about backups. Until now, the only system I trusted 100% was Git. But let’s be real: Git is great for version control, but it is a pain for quick, "oops, go back 10 minutes" restoration. Recovering a project file-by-file is tedious.

I’ve tried the restore buttons on extensions like Kilo Code, Roo Code, and Cline. In my experience, they work maybe 40% of the time if I'm lucky. Usually, they leave the project in a broken state.

Antigravity’s restore function is in a different league. It works, and it works well. I hit the button, and my project instantly reverts exactly to where I need it to be. I still keep Git running for the long haul, obviously, but for those quick, experimental rollbacks? It is a game changer.

The Brains: Gemini 3 Pro & Nano Banana

A year ago, I was laughing at the idea of paying Google $20 a month for AI. Today? $20 feels like a steal.

The value proposition has completely flipped with the release of the new models. I have used literally all of them, and here is the verdict as of writing this:

• Nano Banana: Nothing beats this for image creation. Period. I absolutely love that I can generate these images right through the agent inside the chat window, no context switching required. That said, it isn't flawless; it does fail once in a while, forcing me to ask it to generate again. But considering the convenience and quality, it's a minor grievance.

• Gemini 3 Pro: This is, hands down, the most accurate LLM I have ever used.

Gemini 3 Pro is the best coder I’ve encountered. It’s the most creative, and it has what feels like a never-ending memory. The way it can debug code in a single pass, without me having to nag it five times to fix the same error, is a godsend.

Note: It isn't the fastest model out there, but considering the accuracy, it is absolutely worth the wait.

The "Unlimited" Feel of Rate Limits

If I had to critique one thing, it would be the mystery of the rate limits. Some days I’m coding non-stop all night and never hit a wall. Other days, the limit seems to pop up a bit sooner than I expect.

However, compared to the competition? It’s night and day.

Coming from Claude’s Pro plan, Antigravity feels like pure freedom. With Claude, it often felt like they were just flipping a switch whenever they felt like it; the limits felt arbitrary and caused constant deadlocks. With the Gemini Pro plan, I rarely feel restricted. It feels as close to "unlimited" as I’ve experienced in a paid tier.

The Verdict

There is a background feature for longer projects in Antigravity that I tried once during the congestion week, so I need to give that another honest go before reviewing it.

But when it comes down to it, while Antigravity is a wonderful code editor, it is Gemini 3 Pro that makes this package shine. The pricing is fair, the safety features let me sleep at night, and the intelligence of the model is unmatched.

If you are on the fence, jump in. It’s a good time to be coding.

He wasn't talking about a new programming language. He wasn't talking about a new framework. He was describing a new way of being. He described writing code by "fully giving in to the vibes," letting an AI handle the syntax while he managed the vision.

At first, people laughed. "Vibe Coder" sounds like a joke title you’d give a Gen Z intern who listens to lo-fi beats while breaking the production database. But the laughter died down quickly when people saw the results. Vibe coders were shipping apps, tools, and platforms faster than senior engineers could set up their development environments.

This shift has triggered an identity crisis. If you build software without writing the code yourself, who are you? Are you a developer? A designer? A fraud? Or are you the future?

This article explores the reality of the Vibe Coder, connects it to the lessons of the WordPress era, and finally answers the burning question: What do we call ourselves now?

Part 1: The Chef vs. The Creative Director

Let’s start with the question that started this conversation: Is a vibe coder a web developer?

The answer is nuanced: Technically no, but functionally yes.

To understand why, we have to look at intent versus implementation. For decades, being a "developer" meant you were a master of implementation. You knew the syntax. You knew memory management. You knew why the CSS grid was breaking on Safari.

A Vibe Coder doesn't necessarily know any of that.

The best way to visualize this difference is to look at a high-end kitchen.

The Traditional Developer is the Executive Chef

The Chef has knife skills. They understand the chemistry of emulsification. If a sauce breaks, they know exactly how to fix it using science and technique. They take pride in the process of cooking. If you ask them to make a meal, they physically chop the onions.

The Vibe Coder is the Creative Director

The Creative Director might not have great knife skills. In fact, they might burn toast if left unsupervised. But, they know exactly what the meal should taste like. They know how it should look on the plate. They know how the restaurant should smell.

They stand in the kitchen and tell a team of robot chefs (the AI): "Make it spicy. No, too spicy—add acid. Make the texture crunchier."

The Vibe Coder tastes the output and iterates until it matches their vision.

The "Oh Sh*t" Moment

The real difference between these two roles is revealed when things break.

• When a Traditional Developer sees an error, they read the stack trace, find the line number, and rewrite the logic.

• When a Vibe Coder sees an error, they copy it, paste it back into the AI, and say, "Fix this."

So, are they developers? In the sense that they are writing syntax? No. But in the sense that they are shipping working software that solves user problems? Absolutely.

Part 2: The WordPress Lesson (Developer vs. Implementer)

To legitimize the "Vibe Coder," we don't have to look at the future. We just have to look at the past. We have seen this exact dynamic play out before with WordPress.

For the last 15 years, the web industry has drawn a line in the sand between two types of professionals:

1. The WordPress Developer: Someone who writes custom PHP plugins, manages databases, and builds themes from scratch.

2. The WordPress Implementer: Someone who installs a theme, uses a page builder (like Elementor or Divi), and configures plugins to build a site.

Is the Implementer a "Developer"? Most industry pros would say no. They are "Site Builders."

However, the Implementer is often more valuable to a small business. The Implementer can build a marketing site in 2 days for $2,000. The Developer might take 2 weeks and charge $10,000. The client doesn't care about the PHP code; they care that the contact form works.

Vibe Coding is the evolution of the "Implementer." But there is a massive difference. A WordPress Implementer is limited by the tools. If the plugin doesn't do X, they can't do X.

A Vibe Coder is not limited. Because they use AI to generate raw code, they can build anything a traditional developer can build—custom apps, SaaS platforms, complex logic—without knowing the syntax. They are "Implementers" with superpowers.

Part 3: The "Vibe Designer"

This brings us to the visual side of things. If you are vibe coding the frontend, are you a Web Designer?

Yes. In fact, Vibe Coding is arguably the purest form of design that has ever existed.

Traditional web design is full of friction. You have to learn Figma or Photoshop. You have to draw rectangles. You have to mess with hex codes. You have to drag pixels left and right.

Vibe Coding removes the mouse and replaces it with language.

• Traditional Designer: Draws a button, adds a drop shadow, changes font size manually.

• Vibe Coder: "Give me a retro 90s cyberpunk aesthetic. Neon green buttons that glow when I hover. Use a monospace font."

Tools like v0.dev and Lovable are doing for web interfaces what Midjourney did for illustration. They turn words into UI.

But here is the catch—and it’s a big one: You still need taste.

The AI can write the code, but it cannot judge beauty. If you ask for "a modern website" and you have no eye for spacing, typography, or hierarchy, the AI will give you a generic, soulless, or ugly result. A Vibe Coder acting as a designer is a Curator. Your value isn't in drawing the pixels; it's in looking at what the AI produced and knowing why it looks wrong, then asking the AI to fix the padding or contrast.

Part 4: Why "Web Designer" is Too Small a Title

This is the point where many Vibe Coders get stuck. You start building a website. Then you ask the AI to write a Python script to automate your emails. Then you ask it to build a simple iOS app to track your habits.

Suddenly, you are staring at a portfolio that includes:

• A React Web App

• A Python Automation Bot

• A Swift Mobile App

If you call yourself a "Web Designer," you are lying to your clients and underselling yourself. "Designer" implies you only care about how things look. "Python" implies logic, data, and engineering.

The Vibe Coder is the ultimate Generalist. The superpower of the Vibe Coder is that they are Language Agnostic. They don't need to spend 4 years learning Computer Science to switch from Web to Mobile. They just change the prompt.

Because you are building logic, handling data, and creating functional applications across multiple platforms, you have left the world of "Design" and entered the world of Product Engineering.

Part 5: Professionalizing the Vibe (What to put on your LinkedIn)

So, we know what you do. You orchestrate AI to build full-stack software across different platforms. But "Vibe Coder" sounds unprofessional, and "Web Developer" implies you know syntax that you don't actually know.

What do you call yourself?

Based on our breakdown of the industry, here are the three professional paths for a Vibe Coder.

1. The "Product Engineer" (The Builder)

This is the most accurate title for someone who uses AI to build apps.

• Why it fits: "Engineering" implies building a structure that works. "Product" implies you care about the outcome, not the code.

• The Pitch: "I don't just write code; I engineer complete products. I use AI-augmented workflows to move from idea to MVP in days, not months."

2. The "Rapid Prototyper" (The Corporate Asset)

Companies are desperate for this role. They have ideas, but their engineering teams are bogged down in backlog.

• Why it fits: It sets the expectation of speed. You aren't building the "forever code"; you are building the "proof of concept."

• The Pitch: "I can take your stakeholder's napkin sketch and turn it into a working, clickable, functional application by Friday."

3. The "Technical Generalist" (The Solver)

This is for the Vibe Coder who builds Python scripts, web apps, and mobile tools indiscriminately.

• Why it fits: It highlights your versatility. You aren't a specialist in React; you are a specialist in solving problems using whatever tech stack the AI recommends.

The Future is Hybrid

The boundaries are dissolving.

In 2020, you were either a Coder or a Non-Coder. In 2025, we are all just Builders.

The Traditional Developers are becoming Vibe Coders because it makes them faster. They use AI to write the boring stuff so they can focus on the complex architecture.

The Vibe Coders are slowly becoming Developers because they are learning by doing. After asking the AI to fix a Python error 50 times, you eventually start to recognize what Python syntax looks like. You start to understand the logic.

A Product Engineer… a Maker, or a Vibe Coder, the reality is the same: The barrier to entry for creation has collapsed.

You no longer need permission from a compiler to build your idea. You just need a vision, a prompt, and the "vibe" to see it through.

I’ve been living in the Claude Code CLI lately. It’s a powerful workflow, but it has a glaring friction point: managing connections.

If you’re like me, you bounce between the official Claude subscription and other providers like Z.ai. The standard way to handle this involves exporting environment variables, editing shell profiles, and constantly restarting terminal sessions to make the changes stick. It’s tedious, and it breaks my flow.

I wanted a way to swap contexts without touching a command line or messing with my .bashrc. So, I built Claude Code EZ Switch.

Today marks the v1.0 Stable Release. Here is why I built it and how it differs from other tools out there.

A Simpler, Focused Alternative to Claude Code Router

If you’ve looked for solutions to this problem, you might have found Claude Code Router. That project is excellent—it’s a robust traffic manager that acts as a local proxy server to route your requests.

But for my needs, running a local proxy server was overkill. I didn't need to intercept traffic; I just needed to update my configuration.

EZ Switch is the "lite" alternative.

• No background processes: It doesn't run a server. It’s just a configuration editor.

• GUI-first: It replaces command-line flags with a simple visual dashboard.

• Z.ai Optimized: It is purpose-built to handle Z.ai’s specific API requirements out of the box.

Think of Router as a traffic cop, and EZ Switch as a remote control. If you want deep architectural control, use Router. If you just want to click "Z.ai" and get back to coding, EZ Switch is likely a better fit.

A Cleaner Approach: Settings.json Only

The biggest technical improvement in v1.0 is how it talks to Claude.

In the alpha versions, the app modified system environment variables. This was messy—it polluted the shell environment and often required a terminal restart to take effect.

I’ve scrapped that approach. The app now interacts exclusively with Claude Code’s internal file: ~/.claude/settings.json.

This offers two distinct advantages:

1. Isolation: It never touches your system, terminal, or shell config. It only touches Claude.

2. Speed: You don't need to restart your terminal or source your profile. Just apply the config in the app and restart the Claude Code extension/session.

Granular Control for Z.ai Users

The main reason I built this was to get better performance out of Z.ai without the manual setup.

Claude Code uses three tiers: Opus (complex), Sonnet (balanced), and Haiku (fast). Mapping these to Z.ai’s GLM models manually is annoying.

I added an Advanced Model Selection panel directly into the UI. You can now mix and match explicitly:

• Complex Tasks: Force the Opus tier to use GLM-4.6.

• Quick Tasks: Force the Haiku tier to use GLM-4.5-Air.

This lets you balance cost and logic capabilities without looking up model strings every time.

Curious About Z.ai?

If you haven't tried Z.ai yet, you might be wondering why I prioritized it in this tool.

Essentially, Z.ai gives you access to the GLM model family, which is surprisingly potent for coding workflows.

• GLM-4.6 is their heavy hitter. In my testing, it handles complex reasoning and architectural questions on par with the top-tier models we're used to.

• GLM-4.5-Air is the opposite—it’s optimized for extreme speed and low latency, making it perfect for quick syntax checks or simple refactors.

If you want to give their GLM Code Plan a shot, you can use my link below to get 10% off.

👉 Get 10% off Z.ai GLM Code Plan

Installation (Yes, there is an .exe)

I didn't want this to be another Python script you have to debug before using.

• Windows: I’ve compiled a standalone .exe. You don't need Python installed. Just download and run.

• Mac/Linux: The standard Python source is available and lightweight.

You can grab the release below.

Download v1.0 on GitHub

Let me know if it helps your workflow.

– Ray

While this got you up and running, Anthropic has quietly introduced a significant architectural shift. There is now a standalone native installer that removes the dependency on your global Node environment.

For users currently running the npm global version, there is a built-in migration path you should take immediately to ensure your AI coding partner runs smoothly, securely, and without "permission hell."

The Problem with the Old npm Install

Running powerful CLI tools via global npm installs often leads to friction that breaks the "magic" of an AI agent. You might have encountered:

• Permission Errors (EACCES): Constant warnings that Claude can't write to its own configuration files or update itself.

• The sudo Trap: Being forced to run sudo claude (Linux/macOS), which gives an AI agent root access to your machine—a massive security risk.

• Node Version Conflicts: Claude Code crashing because your project is locked to Node 14, but the agent requires Node 18+.

• Performance Overhead: The npm version relies on the Node runtime, which adds startup latency compared to the new compiled binary.

The Solution: claude migrate-installer

Anthropic has included a dedicated utility to solve this. They are moving users to a standalone native binary. This version lives in your local user directory (e.g., ~/.claude/bin), manages its own auto-updates, and runs independently of the Node version installed on your system.

Best of all? One command handles the entire switch for you.

How to Migrate (All Operating Systems)

Whether you are on macOS, Windows, or Linux, the migration command acts as a bridge from the npm package to the native binary.

1. Run the migration tool Open your terminal (PowerShell, Terminal, or WSL) and run:

Bash

claude migrate-installer

2. What happens in the background?

• Downloads the Binary: The tool detects your OS and downloads the correct native executable (e.g., the .exe for Windows or the Mach-O binary for macOS).

• Relocates Config: It moves your authentication keys and settings to ~/.claude/local, ensuring you don't lose your login state.

• Updates Shell Path: It modifies your profile (like .zshrc, .bashrc, or Windows User PATH) to point to the new binary instead of the global npm package.

3. Verify the Switch Once the command finishes, restart your terminal to ensure the new PATH takes effect. Then, run the diagnostic tool:

Bash

claude doctor

Look for the Install Method line in the output. It should now say native or local instead of npm.

OS-Specific Notes

While the migration command is universal, here are specific details for your setup:

🪟 Windows Users

• PowerShell vs. WSL: If you use Claude Code inside WSL (Windows Subsystem for Linux), run the migration command inside your WSL terminal. If you use it in PowerShell, run it there.

• Performance Boost: Windows users will see the biggest speed improvement. The native binary bypasses the slow file system translation often associated with running global node modules on Windows.

🍎 macOS Users

• Homebrew Option: If the migration command fails or you prefer a fresh start, you can now install the native version directly via Homebrew:

  Bash

    brew install --cask claude-code
  

  However, using migrate-installer is preferred first as it preserves your existing configuration.

🐧 Linux Users

• Sudo Clean-up: If you previously installed Claude Code using sudo npm install, the migration tool is essential. It moves ownership of the tool back to your user account, meaning you never have to type sudo to update Claude again.

Troubleshooting: "Double Install" Issues

Occasionally, your system might get confused if the old npm version isn't fully removed from your PATH. If claude doctor still reports "npm" after you migrate and restart your terminal, you should manually remove the old package to prevent conflicts:

Bash

npm uninstall -g @anthropic-ai/claude-code

Wrapping it up

Migrating to the native installer isn't just about fixing bugs—it's about future-proofing your workflow. The native version is faster, more secure, and decouples your AI tools from your project's Node.js dependencies. By spending thirty seconds running this migration today, you ensure that your coding assistant remains reliable and up-to-date automatically.

But if I was excited on Tuesday, I’m absolutely floored today.

Google just pushed update 1.11.5, and it brings a feature with arguably the best name in developer tool history: Nano Banana Pro. Don't let the fun name fool you—this is a serious upgrade to how we interact with our codebase.

The Power of Nano Banana Pro

"Nano Banana" is the internal codename for the engine behind the IDE's new visual capabilities. Until now, coding agents were brilliant at text—refactoring functions, writing tests, and answering chat queries. With Nano Banana Pro, the changelogs indicate that agents have effectively gained "sight" and design intuition.

The big differentiator here is grounding. The promise is that the agent won't just hallucinate pretty pictures; it generates assets based on your specific codebase and knowledge graph.

What this unlocks for us:

• Context-Aware UI: The ability to ask for a UI mockup that actually pulls from your existing component library rather than generic HTML.

• Instant Documentation: Generating system diagrams that accurately reflect your current architecture.

• Embeddable Assets: Creating placeholder icons or graph visuals directly in the editor without switching context.

Note: The changelog mentions this is rolling out incrementally, so keep an eye out for the update hitting your client.

Frictionless "Thinking" with Scratch Directories

While the visual tools are the flashiest part of 1.11.5, there is a subtle workflow change that looks like a massive quality-of-life improvement.

The Fix: Agents can now create scratch directories if no workspace is open.

This sounds minor, but it’s huge for flow. Before today, you usually had to initialize a project to get the agent working. Now, if you just want to brainstorm a quick algorithm or have the agent prototype a script, you can launch Antigravity and start chatting immediately. The agent handles the sandbox creation autonomously.

A Week of Rapid Iteration

We are only 48 hours post-launch, and the Antigravity team is moving fast. Looking back at the changelogs from earlier this week (v1.11.3), they've already crushed the Day 1 bugs:

• Inclusivity: Fixed support for non-Latin characters in user names.

• Clarity: Better messaging on quota limits (distinguishing between your limit and global capacity).

• Settings: Patching the telemetry settings toggle on the settings page (fixed in today's 1.11.5 update).

Ray’s Take

I love the direction this is heading. We often talk about "10x developers," but tools like Antigravity seem to be aiming to make that a reality by removing the grunt work.

– Ray

Today, Google answered that question with a resounding boom.

In a move that frankly took me by surprise, Google has dropped Antigravity, a brand-new, standalone Integrated Development Environment (IDE). This isn't just an extension for VS Code; it is a fully realized platform designed from the ground up for an "Agent-First" paradigm.

I have spent the morning tearing through the documentation and running my first few "missions" with it, and I have to say: the hype appears to be real. Antigravity isn't just trying to help you write code; it is trying to be your partner in building software, capable of planning, executing, and verifying tasks across your terminal, editor, and browser autonomously.

Here is a comprehensive deep dive into everything we know about Google Antigravity, why it feels different from everything else on the market, and why you should download the public preview immediately.

What is Google Antigravity?

At its core, Antigravity is a fork of Visual Studio Code (VS Code). This is a brilliant strategic move because it means the interface is instantly familiar to millions of developers, and it maintains compatibility with the massive ecosystem of existing plugins.

However, calling it a "VS Code fork" does it a disservice. Google has gutted the operational philosophy of the traditional IDE and replaced it with an engine powered by Gemini 3, their newest and most capable Large Language Model (LLM).

The defining characteristic of Antigravity is that it is Agentic. Traditional AI tools wait for you to type or ask a specific question. Antigravity is designed to be given a high-level goal—like "Refactor this authentication service" or "Build a landing page based on this sketch"—which it then breaks down into subtasks, plans out, implements, and (crucially) verifies on its own.

The "Agent-First" Philosophy

Google describes Antigravity as a shift from "passive suggestion" to "active partnership." This is built on four core tenets that seem to solve the biggest frustrations developers have with current AI tools:

1. Trust via Artifacts: Instead of a black box where code just appears, Antigravity generates "Artifacts"—documents like implementation plans and task lists that you can review before the agent destroys your codebase.

2. Autonomy: The agent isn't trapped in a chat box. It has permission (if you grant it) to roam across your terminal, your file system, and even a browser to get the job done.

3. Feedback: You don't just accept or reject code. You can comment on the agent's plans, mark up screenshots it takes, and guide it mid-flight.

4. Self-Improvement: The system uses "Knowledge Items" to learn from your preferences and past projects, meaning it should theoretically get smarter the longer you use it.

A Tale of Two Interfaces: Editor vs. Manager

One of the most innovative aspects of Antigravity is how it handles the user interface. It recognizes that working with an agent is different than working in code.

1. The Antigravity Editor

This is the synchronous view. It looks like the IDE you know and love. You have your code, your terminal, and your file tree. However, the AI integration is far deeper. You have smart tab autocompletion, context-aware suggestions, and a side panel where you can chat with the agent for immediate, "fast-mode" tasks.

2. The Agent Manager (Mission Control)

This is the game-changer. Antigravity introduces a "Manager" surface—essentially a mission control center.

In the Manager, you aren't necessarily looking at code. You are looking at Workspaces and Task Groups. You can spawn an agent to do background research in one workspace while you code in another. It flips the paradigm: instead of the agent living inside your editor, your editor is just one tool the agent uses.

• The Inbox: This acts as a central hub for notifications. If an agent needs permission to run a sudo command or wants you to review a UI change, it pops up here.

• Asynchronous Handoffs: You can define a task, set the agent loose, and close the window. The agent continues working in the background.

The Workflow: Plan, Act, Verify

How does it actually feel to code with Antigravity? The workflow is distinctively structured to prevent the AI from hallucinating complex logic.

Step 1: The Planning Phase & Task Groups

When you assign a complex task (in "Planning Mode"), the Agent doesn't just start typing. It creates a Task Group.

• It analyzes the request.

• It generates a Task List (an Artifact) breaking down the job.

• It creates an Implementation Plan (another Artifact).

This is where the "Trust" comes in. You can read the Implementation Plan. It outlines the technical details, the files it will touch, and the logic it will use. You can comment on this plan like a Google Doc. Only once you click "Proceed" (or if you set your policy to "Agent Decides") does it start coding.

Step 2: Execution & The Browser Subagent

This is perhaps the most impressive technical feat. Antigravity includes a Browser Subagent.

If you ask the agent to "Change the button color to blue and verify it works," the agent will:

1. Modify the CSS/Tailwind code.

2. Spin up the local server via the terminal.

3. Actually open a Chrome instance, navigate to localhost, and "look" at the page.

It uses a specific model (Gemini 2.5 Pro UI Checkpoint) to "see" the DOM and pixels. It can click, scroll, and type. While it works, it shows an overlay on the browser so you can see exactly what it's doing.

Step 3: Verification & Walkthroughs

Once the job is done, the agent presents a Walkthrough Artifact. This is a summary of what changed, why it changed, and proof that it works.

• Screenshots: The browser agent takes screenshots of the UI before and after.

• Recordings: You can watch a video playback of the agent interacting with your app.

• Diff Reviews: A clean UI to see file changes side-by-side.

Under the Hood: Models and Intelligence

You might expect Google to lock this down to only Gemini, but they have taken a surprisingly open approach.

The Brain: Gemini 3 The default reasoning engine is Gemini 3 Pro. Google claims this model handles "million-token context windows," allowing it to ingest your entire repository. This is vital for large monorepos where context is usually lost.

Model Optionality In the settings, you can actually swap the reasoning model!

• Anthropic: You can select Claude Sonnet 4.5 (and the "Thinking" variant).

• OpenAI: Support for GPT-OSS.

• Google Vertex: Various flavors of Gemini.

This "sticky" setting persists per conversation, giving you the flexibility to use the model that fits your specific coding style.

Specialized Sub-Models Antigravity isn't just one LLM; it's a stack of them:

• Nano Banana: A model specifically for generative images (used for UI mockups).

• Gemini 2.5 Pro UI: For the browser agent to understand web pages.

• Gemini 2.5 Flash: For fast background context summarization.

Connecting to the World: MCP Integration

Antigravity supports the Model Context Protocol (MCP). If you aren't familiar with this, it's a standard that allows the IDE to securely connect to external tools and databases.

This means Antigravity doesn't just know your code; it can know your infrastructure.

• Database Awareness: Connect it to Neon or Supabase, and the agent can read your schema to write perfect SQL queries.

• Issue Tracking: Connect it to Linear or GitHub. You can say "Fix the bug reported in issue #102," and it will fetch the ticket details automatically.

• Documentation: Connect it to Notion or internal wikis to understand business logic.

The MCP Store is built right into the editor, featuring integrations for Heroku, Stripe, MongoDB, and more.

Knowledge Items: The Memory System

One of the biggest annoyances with AI coding is repeating yourself. "Use single quotes," "We use Tailwind here," "Don't touch that legacy file."

Antigravity introduces Knowledge Items (KIs). This is a persistent memory system.

• Auto-Generation: As you work, the system analyzes your corrections and creates KIs automatically.

• Explicit Creation: You can tell it, "Here is our style guide," and it saves it as a KI.

When the agent starts a new task, it scans your Knowledge Items. If a KI is relevant, it retrieves that context. This suggests that the agent will become a better "employee" the longer it works in your specific codebase.

Safety, Security, and Controls

Giving an AI autonomous control over your terminal and browser is terrifying. Google clearly anticipates this fear and has built in several layers of "Safety Rails."

1. Artifact Review Policy You can configure how much autonomy the agent has via three settings:

• Always Proceed: The agent goes full cowboy mode.

• Request Review: The agent must ask for permission before implementing a plan.

• Agent Decides: A hybrid approach where the agent judges the risk level.

2. Terminal & Browser Permissions

• Allowlist/Denylist: You can set specific terminal commands that are allowed or denied.

• BadUrlsChecker: The browser subagent checks URLs against a Google safety service. You can also locally allowlist specific domains (like your localhost ports) so it doesn't wander off to random websites.

3. Local Secret Protection By default, the agent only accesses files in the workspace. There is a setting to "Allow Agent Non-Workspace File Access," but it is off by default to prevent the AI from accidentally reading your global .ssh keys or other sensitive data.

Pricing and Availability

Here is the best part: It is currently free.

Google has launched Antigravity in Public Preview.

• Cost: No charge for individual users.

• OS Support: Available for macOS (Monterey+), Windows 10/11, and Linux (Ubuntu, Debian, Fedora).

• Rate Limits: Google describes them as "generous." They refresh every five hours. While there is a cap, they model that very few power users will hit it. It seems they are subsidizing the heavy compute of Gemini 3 to get adoption data.

There is currently no paid enterprise tier, but the documentation hints that this is for "individual accounts" under Google's standard terms, implying a paid "Pro" or "Team" version is inevitable.

Comparison vs. The Competitors

While I need more time to benchmark this properly, the specs suggest Antigravity is aiming higher than Cursor.

• Context: Gemini 3’s million-token window is significantly larger than what most local copilot setups offer.

• Autonomy: Cursor acts largely as a super-powered autocomplete and chat. Antigravity's "Manager" interface and "Task Groups" suggest a workflow where the human manages the AI, rather than just chatting with it.

• Browser Integration: Native, autonomous browser control for verification is a feature most other IDEs rely on third-party plugins or hacky workarounds to achieve.

The "Liftoff" Moment?

Google Antigravity represents a massive swing. By forking VS Code, they solved the barrier to entry. By integrating Gemini 3 and the Agent Manager, they are attempting to solve the workflow bottleneck.

This isn't just about writing code faster; it's about offloading the mental overhead of planning, context switching, and verification. The ability for an agent to write code, run it, see the error in the browser, and fix it without my intervention is the "Holy Grail" of agentic coding.

What's Next? I am currently running Antigravity through a gauntlet of tests:

• Refactoring a messy legacy Python backend.

• Building a React frontend from a napkin sketch.

• Testing the MCP integration with a live Postgres database.

Stay tuned for a follow-up post where I will share the results of these tests, including where the agent failed (because it will fail) and where it succeeded.

I am super excited that Google did this. It was a huge surprise, and it finally feels like a stable Agentic Era of software development has officially arrived.

The artificial intelligence revolution has transformed how professionals work, but the associated costs can quickly spiral out of control. For months, I found myself spending $240 monthly on Claude Sonnet subscriptions, watching my AI expenses accumulate to nearly $3,000 annually. This changed dramatically when I discovered z.ai's annual subscription package, currently available for just $36 per year—a staggering 99% reduction in my AI spending.

The Cost Crisis of Premium AI

Claude Pro subscriptions typically cost around $20 per month per user, with advanced tiers reaching $100 to $200 monthly. For heavy users requiring multiple seats or API access, these expenses multiply rapidly. The reality became clear: premium AI assistance was consuming a significant portion of my professional budget without sustainable long-term viability.

Discovering the z.ai Alternative

Z.ai emerged as a compelling solution with its GLM Coding Plans, offering frontier-level AI capabilities at a fraction of traditional costs. The platform provides subscription tiers that cater to coding professionals, powered by advanced language models that efficiently support coding workflows.

The $36 Annual Breakthrough

Most exciting was the annual subscription offer for only $36 per year. This pricing is extraordinary compared to premium plans costing hundreds monthly. Even with such a drastic cost reduction, the value offered remains high for coding tasks.

Marginal Differences in Coding Quality

Benchmark comparisons show that while Claude Sonnet often leads AI coding benchmarks by a narrow margin, the differences between it and z.ai's GLM-4.5 and GLM-4.6 models are minimal for most practical uses. In real coding tasks, z.ai delivers strong accuracy and problem-solving ability with only a slight drop in code quality and reasoning depth. This means the trade-off in quality for 90-99% cost savings is very reasonable—developers and hobbyists alike can rely on z.ai without significant sacrifices. The models excel at generating, debugging, and optimizing code with responsiveness comparable to premium options but at a fraction of the price.

Features That Justified the Switch

Z.ai extends beyond basic chat functionality to include comprehensive professional tools tailored for coders. The system supports common programming languages, integrates with typical development workflows, and offers smart assistance for bug fixes and code explanations. This suite met all my needs previously served by costlier AI subscriptions.

Maximizing Your Savings

For those considering this transition, an exclusive 10% discount is available through my affiliate link: https://z.ai/subscribe?ic=NTFSWJTGB0. This additional saving makes the investment even more attractive for budget-conscious developers.

The Bottom Line

Switching from paying $240 monthly on Claude Sonnet to $36 annually with z.ai is a game changer for AI-assisted coding. The marginal compromise in coding output quality is vastly outweighed by the financial benefits. For anyone seeking powerful coding AI without the prohibitive costs, this switch is undoubtedly worth it. Z.ai's combination of advanced capabilities and affordability positions it as the pragmatic choice for the modern coder focused on innovation and budget efficiency.