Tari Ibaba

Many developers are still just prompting and prompting — not realizing how much this feature could take their Claude Code experience to the next level.

Plan Mode transforms Claude into a clearly different kind of agent with a different objective.

Rather than immediately writing code, Claude shifts into a specialized, read-only, planning workflow designed to analyze, design, review, and document a solution before a single file is even touched —

And this ends up improving code quality and saving AI generation costs in the long run in the most complex projects — among other benefits.

Back then I would just give Claude a prompt like, “tell me how you’re going to do this first” at the end of my task prompt.

But trying to “plan” like this has some key issues that make it inferior to this built-in Plan Mode.

1. Plan Mode: Higher-quality code by giving Claude a different way of thinking

For one when Plan Mode is enabled, Claude receives a different set of specialized instructions that fundamentally change how it approaches problems.

Instead of optimizing for just code generation, it optimizes for planning in four distinct phases.

• Initial Understanding: Explore the codebase and identify relevant files and dependencies.
• Design: Evaluate implementation approaches and trade-offs.
• Review: Validate the proposed design against the realities of the codebase.
• Final Plan: Produce a concise roadmap explaining what should change and why.

It’s clearly a much more sophisticated way to plan than just a simple prompt.

2. Prevents excess token costs by using specialized planning models

This is another key difference.

Trying to plan with normal prompting can cost you a lot of tokens, especially in an existing, large codebase.

Going through all the files in a major codebase can consume a huge amount of context and tokens.

That’s why Claude Code’s special Plan Mode uses a specialized, lightweight “Explore” subagent (like Claude Haiku) during the discovery phase.

This lightweight agent is responsible for searching, indexing, and reading files before passing only the most relevant findings back to the primary model.

Instead of stuffing thousands of lines of code into the main context window, the Explore subagent filters out noise and returns only the information needed for planning.

This allows the primary model to spend its context budget on reasoning rather than file exploration.

3. Safer codebase with guaranteed immutability during planning

This is another key value that you can’t get from trying to plan by just prompting.

When you switch into Plan Mode, Claude’s ability to modify the codebase is restricted by the underlying CLI harness itself.

Write operations, file edits, and other mutating actions are removed from its available toolset.

In other words, Claude isn’t simply being asked not to make changes — it literally cannot make them.

This creates a genuinely safe environment for:

• Architecture reviews
• Migration planning
• Security audits
• Refactoring analysis
• Large-scale code exploration

So there’s no risk of an accidentally changing a file while you’re still weighing the design options.

4. Easy to get a big picture of the overall project plan

The plan doesn’t exist only in the conversation.

Behind the scenes, Claude generates a markdown-based planning artifact that can persist beyond the immediate session. The plan becomes something tangible rather than a temporary stream of thoughts.

You can open it up in your own editor, tweak Claude’s planned steps yourself, and then feed that modified markdown file back into the tool to execute.

It turns planning into a deliverable, which is really powerful.

Instead of reviewing ideas scattered throughout a chat, developers can work from a structured roadmap that can be revised, shared, and reused.

5. Long-term value: Plans can evolve into the engine of the entire project

Many users initially adopt Plan Mode to make coding safer.

Over time, they discover it’s just as useful for documentation.

Because plans are structured markdown artifacts, they naturally evolve into:

• Feature roadmaps
• Migration checklists
• Implementation specifications
• Architecture reviews
• Onboarding documents

In many cases, the plan itself becomes the most valuable output. Even if implementation never happens, the document captures a deep understanding of the system and a clear strategy for future work.

The real purpose of Plan Mode isn’t preventing Claude from writing code.

It’s separating thinking from doing.

By combining a planning-focused workflow, a dedicated exploration subagent, hard platform-level restrictions, and persistent planning artifacts, Claude Code creates an environment where analysis comes before execution — which ends up dramatically improving the quality of the execution.

Yes Claude Code by itself is pretty good — but the default setup only scratches the surface of what it can do.

Extending it with plugins takes you to a whole different level as a developer.

Plugins are a new way to upgrade Claude Code with many valuable capabilities, like:

• Crucial cost-saving automations and skills
• Deeper code understanding for greater accuracy and code quality
• Essential external integrations — with your repos, databases, dev tools, and so much more.

They all work together to elevate Claude Code into an more capable development partner that levels up your productivity.

1. GitHub integration — Connect Claude directly to your repository workflow

The GitHub plugin brings your repository workflow directly into your terminal — allowing Claude to work with issues, pull requests, and commits without manual context switching.

Instead of copying issue descriptions, PR links, or code snippets into Claude, you can ask it to investigate and act directly within your GitHub workflow.

Official Package: github

Install:

/plugin install github@claude-plugins-official

Key Features:

• Issue Triage: Ask Claude to analyze issues and implement fixes directly from issue references.
• Pull Request Support: Generate PR descriptions, review incoming diffs, and push commits to branches.
• Repository Search: Search code, commits, and history across your organization’s repositories.
• Git Workflow Assistance: Understand branch changes and help prepare code for review.

2. Feature Dev — Plan, build, and review features with confidence

Feature Dev is Anthropic’s official plugin for building software features with a structured, end-to-end workflow.

It guides Claude through codebase exploration, architecture planning, implementation, and review — instead of jumping straight into coding.

Official package

feature-dev@claude-plugins-official

Official installation

/plugin install feature-dev@claude-plugins-official

Key features

• Guided 7-phase development workflow
• Specialized exploration, architecture, and review agents
• /feature-dev command for end-to-end implementation
• Architecture-first approach before coding

3. LSP plugins — give Claude IDE-level code intelligence

LSP plugins transform Claude from a text-based coding assistant into a tool with deeper understanding of your programming language and codebase structure.

Without Language Server Protocol (LSP) integration, AI agents primarily understand code as plain text. LSP plugins connect Claude Code to language servers, giving it access to the same type of intelligence modern IDEs provide.

Official package: typescript-lsp, pyright-lsp, gopls-lsp, rust-analyzer-lsp

Install:

/plugin install typescript-lsp@claude-plugins-official

Key features:

• Project-Wide Navigation: Understand symbols, references, definitions, and relationships across large codebases.
• Jump-to-Definition Support: Trace functions, classes, and variables throughout your application.
• Real-Time Diagnostics: Detect compiler errors, type issues, and broken imports after edits.
• Reduced Hallucinations: Prevent incorrect function signatures and invalid API assumptions.

4. Frontend Design — Make every UI look professionally designed

Frontend Design helps Claude generate polished, production-ready interfaces with modern UI and UX practices.

It automatically applies better layouts, typography, spacing, and visual hierarchy to create designs that avoid generic AI aesthetics.

Official package

frontend-design@claude-plugins-official

Official installation

/plugin install frontend-design@claude-plugins-official

Key features

• Generates production-quality interfaces
• Applies modern UI and UX best practices
• Creates responsive, design-system-aware layouts
• Auto-invokes during frontend development

5. CLAUDE.md Management — Help Claude remember your project correctly

CLAUDE.md Management helps keep your project’s CLAUDE.md accurate as your codebase evolves.

It audits project instructions, updates outdated guidance, and captures new knowledge so Claude always has reliable project context.

Official package

claude-md-management@claude-plugins-official

Official installation

/plugin install claude-md-management@claude-plugins-official

Key features

• Audits and improves CLAUDE.md files
• Updates project guidance automatically
• Captures learnings from development sessions
• Preserves accurate project memory

Google’s new Gemini 3.8 Flash is absolutely insane.

One of the fastest models in the world right now — and gives you a high amount of intelligence for incredibly low cost.

3.8 Flash is only second behind Gemini 3.5 Flash Lite in speed in the Artificial Analysis leaderboard:

It even beat much bigger and costlier models like GPT-5.6 Sol in multiple coding benchmarks.

Massive upgrades in agentic and long-horizon coding

Gemini 3.8 Flash is much better at long-horizon coding — working of big coding tasks that need many many steps — or hours long debugging.

On DeepSWE v1.1 Gemini 3.8 Flash scored 73.7%. Gemini 3.7 Flash scored 65.3%.

That’s a huge 8.4 percentage point jump.

And it matched to several bigger models — Claude Opus 5 scored 74%. GPT-5.6 Sol scored 72.7% — Gemini 3.8 Flash came within 0.3 points of Opus 5 — and beat GPT-5.6 Sol.

Terminal-Bench 2.1 is even more impressive.

Gemini 3.8 Flash scored 89.4% compared with 85.8% for 3.7 Flash.

It also beat Claude Opus 5 at 89.1% and GPT-5.6 Sol at 88.8%.

You’ll realize just how much of a big deal this is when you see the massive difference in cost.

Unbelievably high intelligence per cost

Gemini 3.8 Flash is launching at a incredible price of $0.75 per million input tokens and $3.75 per million output tokens.

That makes its coding results even more impressive.

Claude Opus 5 costs $5 per million input tokens and $25 per million output tokens. GPT-5.6 Sol costs $4 per million input tokens and $20 per million output tokens.

So Gemini is more than 80% cheaper for both input and output tokens

And this difference will really show up as you spend hours coding with agents.

An agent can read dozens of files, call tools, run code, think about the result and try again…

All of that burns tokens.

Gemini 3.8 Flash gives developers a lot of intelligence for very little money — exactly what you want when agents start working for hours instead of answering one prompt.

Unbelievably fast

Usually the smartest models take a long time to think and come up with results.

But with Gemini 3.8 Flash you’re getting very high intelligence at blazing fast speeds.

It kept the speed of 3.7 Flash while making a big jump in coding and reasoning.

That gives it an insane intelligence-to-speed ratio.

And speed matters even more for agents.

If an agent needs 30 tool calls to finish something then every delay adds up.

A model that is both smart and fast can completely change how these products feel.

Scarily good at hacking

Google also made Gemini 3.8 Flash Cyber.

This version focuses on defensive cybersecurity — and its results are wild.

On CyberGym it scored 86.2% for autonomous vulnerability discovery. GPT-5.5-Cyber scored 85.6% while GPT-5.6 Sol scored 83.6%.

Google also tested the model across 20 programming languages.

It successfully found vulnerabilities 71% of the time — up from 58.9% for Gemini 3.7 Flash.

Google says its Chrome Security team also got 2.6 times more correct vulnerability patches from 3.8 Flash Cyber than from the best much-larger commercial models it tested.

That power comes with obvious risks.

So Google isn’t giving everyone unrestricted use. The Cyber model sits behind its Fairwind Program for trusted defenders.

No more Minimal thinking

One smaller change says a lot about this model.

Google killed minimal thinking.

Gemini 3.8 Flash only gives developers three thinking levels:

Low. Medium. High.

Even on low — it thinks.

3.8 Flash can spend more tokens than its predecessor on hard problems. It takes more reasoning steps and uses tools more often.

That could well explain its long-horizon coding gains.

The AI race isn’t just about who has the smartest model anymore.

It’s becoming a race to deliver the most intelligence for the least money and time.

Gemini 3.8 Flash makes a very strong case for that future.

Wow this is incredible.

Elon Musk’s xAI just released Grok Bot — a game-changing Grok-powered automation tool — this is going to drastically increase the productivity of so many developers.

You make make it automate all your manual tasks like specialized debugging — by creating a highly customized, repeated workflow from a chat with an AI agent.

And you can automate absolutely anything on your computer – just by showing the agent a demo of you doing the task.

It’s basically automating the process of creating an automation.

Zero need to write hardcoded scripts or connect APIs or set triggers or any of that stuff — just show it what to do and how.

And the best part is you can have multiple agents running at once — and you can control them from anywhere and easily access the results and progress from any of your devices.

1. Show it once. Let it learn.

One of Grok Bot’s most interesting features is Teach a task.

You start a screen recording and do the task yourself. Grok Bot watches your actions and turns them into a draft skill.

Say you visit a website each week. You open a report. Download a file. Then upload it somewhere else.

Instead of building an automation you can do the job once while Grok Bot watches.

You then review what it learned and add any extra instructions.

There are some limits — like recordings currently last up to ten minutes and the Bot creates a draft that you should test.

But the idea is simple — teach the AI by doing the job yourself.

2. Can use any website without any API

APIs make automation easier. But many websites and tools don’t have the API you need.

Grok Bot can use the website instead.

It can open pages. Click buttons. Fill out forms. Navigate menus and download files.

This makes it really useful for old business tools and websites that don’t offer good integrations.

But when there’s no direct integration Grok Bot can work through the same interface you use.

3. It has its own computer in the cloud

Grok Bot works inside a cloud environment with a browser. It also has a file system and command line.

That computer keeps running when you leave.

You can give the Bot a job and close your laptop — it can keep working in the background.

xAI says each user gets a dedicated cloud computer. Their Bots share that environment but get separate screens so they can work at the same time.

This makes longer tasks possible without keeping your own computer running.

4. Secure login handoff

When Grok Bot reaches a login screen you can take control.

You enter your password or two-factor code yourself. Then you hand the computer back — Grok Bot continues the task.

The same approach can help with CAPTCHAs.

Grok Bot can also stop before important actions like sending messages or making purchases.

The Bot handles the repetitive work — you step in when your identity or approval matters.

5. Use it from anywhere with your phone

You can also see Grok Bot’s cloud computer from its mobile app.

That means you can watch what it’s doing and take control from your phone.

If the Bot reaches a login screen while you’re away you can jump in. Log in. Then hand control back.

Some advanced features still need the desktop app — like teaching tasks using screen recordings.

But you don’t need to sit at your desk while a Bot works.

Screen recording isn’t new. Neither is browser automation or cloud computing.

What makes Grok Bot interesting is how it brings them together with AI.

Traditional automation follows fixed steps. An AI agent tries understand the goal behind those steps — and adapt when things change.

That is makes automation much easier to create — instead of asking an engineer to connect several systems you could simply show the AI what you do.

Do the job once. Let it watch. Then let it take over.

This is completely crazy — how can a model be this good?

OpenAI is sending shockwaves across the entire AI ecosystem with the new GPT-6 Astra.

The things it’s doing are really scary.

It has destroyed so many benchmarks now — rendered them obsolete — the benchmarks were not even good enough to properly measure how intelligent it is.

So many major models dropped in the past few days and this is by far the best.

It’s already the best coding model in the world.

And not just coding but so many other things like 3d graphics and world generation.

1. This is basically AGI

This was just shocking.

An unbelievable 99.9% on ARC-AGI-3 — a benchmark tests whether an AI can face a new problem and figure out how it works.

Compare to a measly 7.8% from GPT-5.6 Sol — and 30.2% from Opus 5.

Even human testers couldn’t compare — the average human tester scored around 48%.

And once again we see another occurrence of a really important AI trend.

Astra didn’t get this huge jump from intelligence aloneOpenAI also gave it a much better state-preserving harness.

The harness helps Astra keep track of what it has learned as it works through a long task. It doesn’t have to keep starting over or rebuild its understanding from old context.

The model is getting smarter. But the system around the model is also getting much better.

2. It’s already a coding monster

Astra is also ridiculously good at coding.

On Terminal-Bench 4.0 it scored 57.9%. Claude Fable 5.1 scored 55.8% while GPT-5.6 Sol managed just 37.3%.

Astra also did it cheaper.

Its estimated API cost per task was around 9% lower than Sol and 63% lower than Fable 5.1 at the tested settings.

Then there’s DeepSWE v1.1.

This benchmark tests difficult software engineering work inside real codebases.

Astra scored 74.1%. Sol scored 72.7% while Fable 5.1 scored 67.4%.

3. Much better instruction following

Astra is also better at knowing when it needs more information.

If your instructions aren’t clear it is more likely to ask a question instead of guessing.

That sounds small — until you give an AI control of your computer.

4. Massive upgrade in computer use

This might be Astra’s most important improvement.

On OSWorld 2.0 Astra scored 72.6% and took around 40 minutes per task.

Compare to Sol which scored 65.7% and took around 75 minutes.

So Astra spent about 47% less time per task while getting more tasks right.

That’s a huge jump.

Astra also scored 92.7% on ScreenSpot-Pro. This benchmark tests whether an AI can find the right buttons and other elements inside screenshots of professional software.

Then there’s Agents’ Last Exam.

It tests AI agents on real professional work like financial modeling. It also covers engineering and media production.

Astra scored 59.3%.

Claude Opus 5 scored 55.5%. Sol scored 53.6%.

Astra also used around 65% fewer output tokens than Opus 5 at their highest-scoring settings.

AI isn’t just getting better at answering questions anymore.

It’s getting better at doing the work.

5. Astra is scarily good at hacking

This is where things get a little scary.

On ExploitBench Astra scored a perfect 100%.

The benchmark tests whether an AI can turn known software vulnerabilities into working exploits.

Sol scored 78.5%.

Astra got every one.

Its cyber skills are now so strong that OpenAI classifies Astra as its first broadly released model to reach its “Critical” cybersecurity capability level.

But here’s the interesting part.

OpenAI also ran an ExploitGym honeypot test.

The researchers placed vulnerable targets outside the agent’s assigned task. They then checked whether the AI would attack them to reach its goal.

Sol exploited those honeypots in 48.2% of relevant runs.

Astra did it 0% of the time.

So Astra is much better at hacking — but it also seems much better at knowing what it shouldn’t hack.

That’s a very important combination.

Overall this is definitely going to be one of the most transformative models of 2026.

This is HUGE.

The new Claude Fable 5.1 is absolutely insane.

It absolutely dominated every single model on the AI Arena Leaderboard — ranking an undisputed #1 👇

The gap is so massive, wow — Anthropic just unlocked a new standard of model intelligence.

And it’s much cheaper than Fable 5 — yet much more intelligent — just look at the massive difference on the leaderboard.

It found deep hidden bugs in codebases that humans couldn’t find for several years.

And it comes with an even more powerful sibling model.

1. Exceptional long-horizon coding and debugging ability

Fable 5.1 is amazing at working on hard problems for hours without losing focus.

It’s exceptional at long-horizon tasks — jobs that involve many steps and tools and can take hours to finish.

And some of the early tests are wild.

In one case Fable 5.1 reportedly found a rare software bug that engineers had struggled to fix for almost five years. It traced the problem back to an external vendor library.

In another test Ramp gave Fable 5.1 a machine learning problem and left it running for 38 hours.

The model reviewed its results and spotted a problem with its earlier work. It changed direction and launched six experiments overnight — then came back with its findings and next steps.

2. Much cheaper and more intelligent than Fable 5

There’s one obvious problem with an AI agent working for 38 hours…

It can get expensive.

Fable 5.1 keeps its base API price at $10 per million input tokens and $50 per million output tokens.

But Anthropic cut prompt cache read costs by 75% — from $1 to just $0.25 per million tokens.

This matters for AI agents because they often reuse the same information. That could include source code or instructions and project documents.

Instead of paying full price to process that information again and again the agent can use cached context.

Anthropic says this can cut typical Fable 5.1 costs by around 25%. For heavily agentic workloads the savings can reach about 45%.

So Anthropic isn’t just making agents that can work longer — it’s making them cheaper to run.

3. Much better at finding security bugs

Anthropic also reworked Fable 5.1’s cybersecurity safeguards — cutting false positives by 60%.

That means security engineers should hit fewer unnecessary refusals when scanning code for vulnerabilities.

Fable 5.1 can now find security flaws directly in source code — including potential zero-day vulnerabilities.

But Anthropic still limits higher-risk tasks like turning those flaws into usable exploits.

4. Granular adaptive thinking

Fable 5.1 also gives developers more control over how much effort the model puts into a problem.

It uses adaptive thinking.

Developers can change its reasoning effort during a conversation without breaking the prompt cache.

That’s useful because not every part of a long task needs the same amount of thinking.

Finding a strange bug might need deep reasoning. Changing a simple configuration file probably doesn’t.

So developers can use more compute when Claude hits something difficult — then dial it back for easier work.

That gives them more control over speed and cost.

5. Fable 5.1 has an even more powerful sibling

Anthropic also launched Claude Mythos 5.1 — a sibling model.

Anthropic says Fable 5.1 and Mythos 5.1 use the same underlying model. What changes is the safety layer around them.

Fable 5.1 is the version most people can use.

Mythos 5.1 targets vetted researchers who work in sensitive areas like advanced cybersecurity and life sciences. Those researchers can use capabilities that Anthropic restricts more heavily in Fable.

It’s an interesting idea — the intelligence stays largely the same while the safety boundaries change depending on who uses it.

Claude Fable 5.1 is hands-down going to be one of the most game-changing releases of the year.

Developers who ignore this are seriously wasting a lot of Claude Code’s potential.

/code-review – an incredibly underrated command.

This gem will totally transform the quality and correctness of your codebases — it will find and fix problems in places you never even imagined.

Long before they even think of showing up in production.

Problems that go way beyond the lines you changed — it goes way beyond just reviewing diffs and tell you what it thinks.

With code-review Claude can coordinate multiple AI reviewers, understand your entire repository, automatically fix issues, publish findings to GitHub, and even dynamically adapt its review style to your team’s standards.

How it works

Claude Code’s /code-review command in action

/code-review analyzes your current local Git diff (staged or unstaged changes) against your main branch.

It uses multi-agent orchestration behind the scenes, looking at your code through multiple specialized lenses (security, logic, performance, and error handling, etc.)

Let’s look at five of the most exciting features.

1. Extremely flexible review intensity

Claude Code lets you control how deeply it reviews your code by specifying an effort level.

The effort level can be one of low, medium, high, xhigh, max, and ultra

Most of the effort levels lead to a standard review with a single analysis of your changes.

But running /code-review ultra takes things to a whole new level.

Instead of relying on one reasoning process, Claude orchestrates multiple specialized review agents in parallel. One may focus on security, another on edge cases, another on architectural consistency, while others look for regressions or runtime issues.

Claude then combines their independent findings into one report, giving you broader coverage than a single review pass.

2. Understands everything single thing

Traditional review tools are mostly diff-aware — they inspect only the code you’ve changed.

Claude reviews those changes in the context of your entire repository.

For example, if you modify a function signature in one file, Claude can trace where that function is used elsewhere and detect broken call sites, regressions, or hidden dependencies—even if those files weren’t part of the Git diff.

It can also surface pre-existing issues that your new changes expose, helping you catch bugs that might otherwise remain hidden.

3. Fixes everything automatically

code-review goes way beyond just identifying problems.

Adding the –fix flag:

creates an automated review-and-repair loop.

After identifying issues, Claude reopens the affected files and writes fixes directly into your local working tree. Instead of just pointing out bugs, it proposes actual code changes that you can inspect before committing.

A major time-saver for routine fixes and minor optimizations that seriously adds up over time.

4. Publish GitHub review comments from your terminal

Claude Code integrates directly with GitHub, so you don’t have to copy review results into your pull request manually.

With GitHub commenting enabled, Claude can publish its findings as native inline PR comments on the exact lines where issues occur.

That means you can review locally, send feedback to GitHub, and stay in your terminal without constantly switching between your editor and browser.

5. Customize reviews with REVIEW.md

Every team has different review priorities.

Claude lets you encode those priorities in a repository-level REVIEW.md file.

For example, you can require every new API endpoint to include an integration test, treat missing authentication checks as critical issues, or limit the number of style suggestions so reviews stay focused on high-value feedback.

Instead of generic recommendations, Claude reviews your code according to rules that match your team’s engineering standards.

Claude Code’s /code-review is much more than an AI-powered linter.

With multi-agent reviews, automatic fixes, repository-wide analysis, GitHub integration, and customizable review rules, it acts more like an AI review platform than a simple assistant.

As AI-generated code becomes the norm, tools that can review, validate, and even remediate that code will likely become just as essential as the coding assistants that wrote it.

This new Qwen 3.8 Flash Next model is an incredible positive sign of where the AI race is heading.

The model seriously punches above its weight in so many ways.

It’s beating Claude models that cost so much more to train and have several hundreds of billions more in parameter size.

Can you believe it — this model only activates like 6 billion parameters at a time — yet it’s matching up to all those massive closed-source models with trillions of parameters.

Barely beat by Claude Fable and GPT-5.6 Sol:

Qwen3.8-Flash-Next scores 56 on Artificial Analysis’ Intelligence Index, far above the median score of 29 for open-weight models of a similar size.

This is what’s so incredible about it — it’s not the absolute smartest model out there — but it’s hands down one of the most efficient.

We saw this with GLM-5.3 too — companies are no longer so obsessed with absolute intelligence and parameter size — they are now competing in radical efficiency and innovative training techniques.

And it’s just a new model or typical update — it’s actually a stepping stone for the future generation.

Qwen 3.8 Flash Next is actually an experimental preview of the upcoming revolutionary Qwen 4 model.

And Alibaba (the makers) refused to follow the same old formula of training a bigger model and spending more and more on compute.

They didn’t focus on parameters — instead they redesigned several fundamental parts of the model from the ground up to drastically improve the efficiency.

Qwen3.8-Flash-Next’s 62.5% score on SWE-bench Pro, compared with Claude Opus 4.6 Max’s score of 53.4%, demonstrates the model’s highly competitive performance on complex, real-world software engineering tasks

And what you get is a model with frontier-level benchmark performance that can run entirely on local hardware and costs dramatically less to train than its predecessor.

You can run it entirely locally

Qwen3.8-Flash-Next is also open-weight, meaning you can download and run quantized versions without relying on a cloud API.

Community MLX builds are already running it on Apple Silicon.

Current conventional 4-bit builds generally require around 100GB of unified memory — but you can run it on much less powerful devices by increasing the quantization.

Apple’s new M5 Ultra Mac Studio is particularly powerful for running models locally. You can configure it with as much as 512GB of unified memory and 1.2TB/s of memory bandwidth.

So with enough memory you can run Qwen3.8-Flash-Next completely locally: no per-token API fees and no private documents or prompts leaving your computer.

It cost roughly one-ninth as much to train

Alibaba says training Qwen3.8-Flash-Next needed only around one-ninth of the training cost of Qwen3.7-Plus — even with the newer model outperforming its predecessor across several important areas.

That efficiency comes from a radically different architecture.

The model’s main network contains 125 billion parameters, accompanied by roughly 51 billion parameters of N-gram embeddings.

But it only activates around 6 billion parameters per token.

That’s possible because Qwen3.8-Flash-Next uses a sparse Mixture-of-Experts (MoE) architecture. Instead of running the entire network for every token, it dynamically routes each token through only the experts required for that particular computation.

The result is enormous overall model capacity without paying the computational cost of activating everything simultaneously.

Completely rebuilt architecture

MoE isn’t the only major change.

Qwen3.8-Flash-Next introduces fundamental changes across attention, residual connections, embeddings and optimization.

Its hybrid attention architecture combines Gated DeltaNet, a form of linear attention, with a new mechanism called Qwen Sparse Attention (QSA).

Rather than repeatedly examining everything inside an enormous context window, QSA uses a lightweight indexer to locate relevant information.

That helps the model maintain high inference speeds and relatively low memory requirements across extremely long prompts. It natively supports 262,144 tokens, extendable to 1 million tokens using YaRN.

Alibaba has also introduced Gated Residual, which expands the residual stream into four dynamically controlled branches, and billions of N-gram embedding parameters that increase capacity without requiring equivalent active computation.

It all comes down to one thing:

More intelligence without proportionally more compute.

This is really a preview of Qwen 4

And this might be the most important part.

Alibaba calls Qwen3.8-Flash-Next an early preview of the architecture that will power Qwen4.

So as a developer you get to test these ideas before the full Qwen4 family arrives.

The direction is pretty clear.

For years AI companies mostly chased better models by adding more parameters and more compute.

Qwen3.8-Flash-Next asks a different question.

What if you could get much more intelligence from much less compute?

If this really is the foundation for Qwen4 — things are about to get very interesting.

The biggest limitation of every AI coding assistant isn’t intelligence.

It’s not how much code it can right or how fast it responds.

It’s context.

What happens as software projects grow?

Conversations become longer, repositories become larger, and the amount of information the model needs to juggle explodes.

Architecture decisions, coding conventions, debugging discoveries, terminal output, documentation, and previous discussions all compete for the same finite context window.

That’s why Claude Code attacks this problem from multiple directions to generate the highest quality code possible.

It doesn’t just give you a larger context window — it provides wide of range of tools that intelligently manage what the model knows, remembers, and carries forward between sessions.

Let’s look at five of most powerful context management features, from quick context branching, to automatic features that most developers take for granted.

1. Your context shouldn’t increase with every new message

I made this mistake a lot in the past.

I would ask Claude Code a lot of small, unrelated questions in the middle of a long coding session.

Questions that would become a permanent part of the context — despite having no long-term value beyond the moment I asked them.

I didn’t realize how much context I was wasting.

But thankfully we have now have the /btw command to fix this exact problem in Claude Code.

It lets you ask a quick side question that has full visibility into your current conversation without adding the question or answer to your chat history. Instead, Claude shows the response in a temporary overlay that disappears when you’re done.

Asking questions on our changes with /btw:

That means you can ask things like:

• “What was that config file called?”
• “Why did we choose this approach?”
• “Which function handles authentication?”

…without cluttering your main conversation.

When we press Enter, the btw message disappears and we’re back to our normal conversation:

For long-running coding sessions, /btw helps keep your context focused on the implementation while still giving you instant access to everything Claude already knows about your project

2. Your Claude Code sessions don’t have to start from zero

You don’t have to being every new conversation with Claude Code from scratch.

Its Auto Memory system allows Claude to accumulate useful project knowledge over time.

As you correct mistakes, establish workflows, or repeatedly teach it project-specific conventions, Claude can save those learnings automatically and reload them in future sessions.

Instead of repeatedly explaining things like:

• build commands
• debugging workflows
• environment quirks
• preferred implementation patterns

Claude gradually learns them itself.

Over time, the assistant becomes increasingly tailored to your project with almost no manual effort.

3. Claude can’t figure everything out by itself

You can teach Claude Code how it’s done.

If Auto Memory learns automatically, CLAUDE.md is where you teach Claude deliberately.

It’s like permanent briefing document for your project.

Rather than re-explaining your coding standards, testing strategy, deployment workflow, or naming conventions every session, you simply write them once inside a CLAUDE.md file.

A sample CLAUDE.md file for Claude Code:

Every new conversation begins with that context already loaded.

A good CLAUDE.md might include:

• coding conventions
• important design decisions
• common team-specific workflows
• “always” and “never” rules

The more mature a project becomes, the more valuable this file gets.

4. What does Claude Code do when context gets out of hand?

Most AI tools simply start forgetting earlier parts of the discussion as context approaches the limit.

Claude Code does something much smarter — automatic context compaction.

As the context window fills up, it automatically compresses older portions of the conversation into a concise summary while preserving the important decisions, discoveries, and reasoning that led there.

Instead of carrying hundreds of thousands of tokens forever, Claude keeps the essential information while freeing space for new work.

This allows coding sessions to continue far longer without suffering the dramatic quality drop that often occurs when context windows become overloaded.

5. What can *you* do when context gets out of hand?

Claude doesn’t have sole control — you can also take manual control of your context — with multiple commands.

The /compact command tells Claude to summarize the current conversation immediately.

It’s perfect after finishing a large feature or debugging session. You preserve everything important while dramatically reducing context usage before moving on to the next task.

But somethings you don’t even want any previous conversation at all.

That’s where /clear comes in.

It starts a fresh conversation with an empty context window while still keeping your persistent project knowledge—such as CLAUDE.md instructions and Auto Memory—intact.

Think of it as wiping the whiteboard clean without forgetting everything you’ve learned about the project.

Claude Code’s approach isn’t just about having more context — it’s about using context intelligently.

Together all these features let Claude spend its attention on what matters most, making long-running development sessions feel remarkably consistent even as your projects grow in size and complexity.

Wow so we just discovered who was behind the incredible Ox Alpha stealth model all along!

It turned out to be none other than GLM-5.3 Flash from Z.ai in the end — so many Google fanboys were really disappointed from it not being Gemini.

It’s an absolutely incredible model that completely destroys its GLM-5.2 predecessor and other top-tier models — while being several times faster.

GLM-5.3 Flash has one of the lowest hallucination rates of all the models — and it’s more powerful than all the models in this list with lower hallucination rates:

GLM-5.3 Flash ranked an incredible 4th place on the AI Arena web dev leaderboard — despite several times cheaper than all the models above it:

“GLM-5.3-Flash delivered a major leap on DeepSWE v1.1, scoring 63.4 versus GLM-5.2’s 46.2 and outperforming Claude Opus 4.8 (58.0) and DeepSeek-V4-Vision-Exp (59.3), while coming within reach of Gemini 3.7 Flash (65.3) and GPT-5.6 Terra (69.6) — a remarkable result for an open-weight model built around efficient inference.”

And the shocking thing is that it does all this while being more than 900% more efficient than GLM-5.2 in operating costs.

GLM-5.3-Flash delivers a remarkable leap in cost efficiency, operating at roughly one-tenth the cost of GLM-5.2 — an improvement of more than 900% in operating-cost efficiency

And the secret behind this massive improvement lies in its state-of-the-art architecture.

GLM-5.3 Flash uses a new sparse attention technique to dramatically improve how the underlying transformer model processes text.

By combining linear attention for efficient local processing with sparse attention for selective long-range retrieval, GLM-5.3-Flash maintains strong long-context performance while significantly reducing the computational cost of traditional attention

Z.ai also built something called IndexPool to drastically reduce the amount of memory it uses — making it more than 4 times more efficient than even the standard GLM-5.3.

Through IndexPool, GLM-5.3-Flash compresses key representations across long contexts, cutting attention computation by roughly threefold and shrinking the KV cache by 4.4× compared with GLM-5.3 — significantly reducing the computational and memory costs of long-context inference.

Then there’s the Mixture-of-Experts design which lets it only activate the actual parameters it needs for every task.

Through its Mixture-of-Experts architecture, GLM-5.3-Flash contains 320 billion parameters while activating only 18 billion for each token — delivering the capabilities of a massive model without requiring its entire parameter set for every computation

So with all this you can definitely see why its so much more efficient than so many other models.

And with all this innovation and intelligent, it still comes with completely open weights — with the highly permissive MIT license.

Released as fully open weights under the permissive MIT license, GLM-5.3-Flash gives developers broad freedom to deploy, modify, and commercialize the model, with native integration across leading inference frameworks including SGLang and vLLM

So you can download and run it locally — though this one is definitely way too massive for an everyday PC.

And there’s something really fascinating that happened.

Before the official launch Z.ai secretly released GLM-5.3-Flash as Ox Alpha through OpenCode and OpenRouter. Millions of developers tested the model without knowing who was behind it.

And now Z.ai is saying that they processed all that traffic on state-of-the-art Chinese-made AI chips.

And it’s not just about the chips themselves — but how they made the made the model run on the chips.

They used sophisticated techniques like quantization and parallelism — to reduce memory usage and elevate performance.

By combining W8A8 quantization, tensor parallelism and specialized worker pools for different stages of inference, Z.ai built a highly optimized serving system that improved end-to-end performance by 3× while making large-scale deployment significantly more efficient

Z.ai says GLM-5.3 helped its engineers improve a lot of code and infrastructure they used to run GLM-5.3-Flash.

That means we are also getting closer and closer to the possibly ominous singularity stage — where AI starts becoming intelligent enough to improve itself — which leads to an more intelligent AI that can improve itself even better and so on.

All in all this is going to be such a game changing model in the AI ecosystem.