Tari Ibaba

Google is doing something totally mind blowing.

They are trying to kill the IDE. For good.

Many people were rightly expecting their Antigravity tool to get some upgrades in this year’s Google I/O — but they had absolutely no idea just how drastic the changes were going to be.

They went from this — what we’ve all been used to for several decades:

to this — literally just this:

And then later on when you start doing some work:

Google can see the writing on the wall. They understand the unstoppable direction the AI software development landscape is heading in.

The coding editor is totally gone.

Something not everyone is very happy about:

A complete transformation from AI assistant to full-fledged AI engineering team.

1. From AI assistant → genius software engineering team

The first version of Antigravity still lived in the IDE world.

Antigravity 2.0 does not.

Google completely stripped away the editor-first experience and rebuilt the system around projects, not repositories.

Instead of opening folders and files, you manage long-running initiatives while AI agents execute the work. Google literally calls the desktop app “unabashedly agent-first.”

The mental model changes completely:

Old world:

Open repo → write code → commit

Antigravity world:

Define goal → deploy agents → orchestrate execution

You’re no longer pairing with an assistant.

You’re managing a software building organization.

2. An entire OS from scratch

This was the moment that shocked the world.

Google DeepMind gave Antigravity 2.0 a single high-level prompt and had it build a functional operating system — FROM SCRATCH.

The numbers were absurd:

• 93 subagents
• 2.6 billion tokens processed
• Completed in 12 hours
• Total cost reportedly under $1,000 in API usage

And then came the live demo.

Google loaded the classic game Doom onto the AI-generated operating system and ran it live on stage.

During the demo, Antigravity was even prompted to generate missing keyboard drivers in real time, instantly extending the OS and making gameplay possible.

Think about what that means.

A multi-agent system coordinated dozens of autonomous workers, built an operating system, compiled it, extended it live, and ran software on top of it.

This is no longer:

“Build me a React component.”

This is:

Autonomous systems engineering at massive scale.

3. Dynamic subagents are a game changer

Most AI systems break when tasks become too large.

Throw enough complexity at a single model and eventually it loses context, forgets state, or collapses under memory pressure.

Google solved this by turning the primary agent into a manager.

Instead of doing everything itself, it dynamically spawns specialized subagents in parallel.

Those agents work independently, finish subtasks, then merge results back into the main workflow. Google highlighted Antigravity’s move toward coordinated multi-agent execution and orchestration across environments.

Like just imagine this beautiful teamwork:

Agent A → architecture

Agent B → UI

Agent C → tests

Agent D → browser validation

Agent E → deployment

All running simultaneously.

The result:

Massive projects stop feeling like giant prompts.

They become distributed systems.

4. Scheduled Tasks keeps AI working on autopilot

One of the most underrated announcements was Scheduled Tasks.

This changes how people interact with AI.

Instead of sitting at your laptop prompting continuously or hacking something together, you can now seamlessly assign recurring work:

“Review analytics every morning at 8 AM.”

“Refactor stale code overnight.”

“Scan for regressions while I sleep.”

The agents run asynchronously in the background without interrupting active workflows.

This moves AI from:

tool you use → system that operates

5. The slash commands reveal what Google thinks AI is actually good at

Google introduced several new command patterns that feel surprisingly honest about AI limitations.

/grill-me

Before touching anything, the agent interrogates you.

It keeps asking clarifying questions until intent becomes crystal clear.

Google is effectively admitting:

Bad prompts create bad autonomous systems.

/goal

This is the opposite.

Full autonomous mode.

Give the objective.

Walk away.

The agent executes until completion without constantly asking permission.

It’s essentially “fire-and-forget engineering.”

/browser

This one is fascinating.

Google openly acknowledged that agents still struggle with deciding when they should search externally.

So instead of pretending the problem is solved, they added an explicit switch:

Turn browsing on.

Give the agent web access.

Continue.

That transparency is rare.

6. Gemini 3.5 Flash is the engine underneath all of this

None of this works without speed.

Antigravity 2.0 runs on Gemini 3.5 Flash, which Google positioned as the model built specifically for agent workflows, coding, and long-horizon tasks.

Google says it delivers major coding improvements and operates 4× faster than competing frontier models, while Antigravity pushes even more performance inside its environment.

Speed matters even more now in this multi-agent era because agents multiply work.

One slow model = waiting.

Ninety-three agents = bottleneck disaster.

3.5 Flash changes the equation.

Antigravity 2.0 isn’t trying to beat Cursor.

It isn’t trying to beat Copilot.

Google is aiming at something bigger:

Replace the software workflow itself.

The IDE is disappearing.

Repositories are becoming projects.

Developers are becoming orchestrators.

And AI is turning into a software engineering organization.

Wow this is absolutely huge.

Gemini 3.5 Flash is here and it’s a total MONSTER — this is so much more than just another minor upgrade.

This thing is literally FOUR times faster than literally any other model in existence right now.

So much faster than the last version of Flash — yet somehow so much better than the last Pro version in practically every way.

And it goes way way beyond just speed or coding accuracy improvements.

We have now fast moving past the era of one agent doing all the work on its own.

Gemini 3.5 was built from the ground up for multi-agent coding and massive parallelism.

It even now generates sophisticated interactive UIs and high-resolution graphics and demos from your prompts.

1. Massive upgrades in agentic coding, terminal workflows, and software engineering capabilities

The biggest improvement in Gemini 3.5 is software engineering capability.

Gemini 3.5 comes with major upgrades in coding, long-horizon execution, and agent benchmarks — despite Flash traditionally being the speed tier.

The gap is so large now that Gemini 3.5 Flash is effectively replacing what developers previously expected from Pro-class reasoning models.

What stands out is its strength in agentic software workflows:

• Multi-file repository changes
• Long-running engineering tasks
• Terminal-based execution flows
• Sustained planning and execution loops
• Autonomous code modification workflows

Terminal capability especially matters because modern engineering increasingly happens outside the editor:

Git workflows, infrastructure changes, deployments, Docker environments, CI pipelines, Kubernetes operations — these are where many models still degrade.

Gemini 3.5 is much stronger in those environments, particularly on terminal-oriented benchmarks and software execution tasks.

2. Unbelievable gains in speed — blazing fast

Performance matters.

Latency changes behavior.

Google claims Gemini 3.5 Flash reaches roughly 289 tokens/sec, putting it at around 4× the speed of comparable frontier models while maintaining much stronger coding performance.

This matters because agent systems stack latency:

Planner → Subagent → Tool call → Verification → Retry → Execution

Small delays multiply.

When a model becomes dramatically faster, entire workflows become practical:

• Parallel debugging agents
• Continuous architecture reviews
• Autonomous refactoring pipelines
• Background code validation agents
• Multi-repository execution systems

Fast AI feels good.

Very fast AI changes what can exist.

3. Built for parallel agentic workflows from day one

This may be the most important architectural shift.

Most agent systems today were originally built for:

one model → one user → one response

Parallel agents came later.

Teams hacked orchestration layers on top.

Gemini 3.5 takes the opposite approach.

Google designed it around parallel agent execution, where multiple agents can split work, coordinate tasks, and execute simultaneously.

Just imagine this engineering workflow:

Agent A handles refactoring.

Agent B updates tests.

Agent C validates infrastructure.

Agent D generates migration docs.

All running concurrently.

This is no longer a chatbot pattern.

It is distributed software execution.

And it is probably the clearest signal yet of where AI development tooling is heading.

4. World-class external tool use

Coding ability matters.

Tool usage determines whether agents are actually useful in the real-world.

Gemini 3.5 scores massive improvements on MCP Atlas, one of the strongest evaluations for sophisticated tool orchestration and external system interaction.

It beat every single major model at MCP integration and tool usage.

That matters because modern agents increasingly operate through:

• IDE integrations
• APIs
• MCP servers
• CI pipelines
• Cloud systems
• Terminals
• External execution environments

Tool use is becoming the real operating system for AI.

And Gemini 3.5 is exceptionally strong at it.

5. Rich interactive UIs and graphics generated in real time

Gemini 3.5 is also pushing hard into interface generation.

Google showcased richer interactive outputs including generated interfaces, dynamic graphics, visual experiences, and interactive applications generated on demand.

Instead of generating isolated explanations and descriptions, Gemini increasingly generates:

• Interactive interfaces
• Visual systems
• Animations
• Stateful experiences
• Rich graphics

OpenAI just completely transformed the software development ecosystem with their new Codex Chrome extension.

They just unlocked a whole new world of possibilities for what you can accomplish — now that it has access to context from your real browser.

Now it can see your active session and use all those crucial developer services you’re signed in to — which it could never do before an empty sandboxed browser.

Codex can now operate seamlessly across your codebases, repositories, APIs, browsers, and developer tools to work on the most complex goals that need data from all these different environments.

1. Powerful signed-in state access

One of the biggest advantages of the Codex Chrome extension is its access to your real signed-in browser state.

Unlike traditional web crawlers or sandboxed browsers, Codex operates inside your active Chrome profile using your existing sessions, cookies, and authenticated accounts.

Why does that matter?

Because most real work happens behind login screens.

You could tell Codex:

“@Chrome open Salesforce and update the status of my last three leads.”

And it can do it because it’s operating as you inside the browser.

This allows Codex to handle workflows like:

• Triaging emails in your actual inbox
• Updating Jira or Salesforce records
• Pulling information from internal dashboards
• Accessing private company wikis without public APIs

Most AI systems struggle with authenticated enterprise environments. The Codex extension changes that by turning the browser itself into an execution layer for AI agents.

2. Intelligent three-tier execution model

At the center of the system is dynamic tool switching.

When you ask Codex to do something, it automatically decides which tool is best — using a built-in priority stack:

Tier 1: Plugins and APIs

If a dedicated integration exists — such as GitHub, Jira, or Gmail — Codex uses the API first.

This is the fastest and most stable option because APIs provide structured, deterministic access. Instead of visually navigating interfaces, Codex can directly update tickets, review pull requests, or retrieve information.

OpenAI’s approach makes it clear that browser automation is not the default. It’s the fallback when APIs are unavailable or insufficient.

Tier 2: Chrome extension

When a task requires authenticated browser access, Codex escalates to Chrome.

This allows it to operate inside real logged-in sessions:

• Internal dashboards
• CRMs
• Admin tools
• Enterprise web apps
• Sites without usable APIs

Rather than running in an isolated sandbox, Codex works within your existing browser state, including cookies and SSO sessions. This solves one of the biggest limitations of current AI agents: most enterprise workflows happen inside web interfaces, not clean APIs.

Tier 3: In-app browser

For local development environments like localhost:3000 or static previews, Codex stays inside its own browser sandbox.

This keeps developers’ personal Chrome sessions clean while providing safer isolation for testing and debugging workflows.

Together, these three layers allow Codex to choose the least invasive and most reliable path for completing work.

3. Multi-tab background operations

One of the most interesting parts of the extension is how it handles browser automation.

Unlike traditional automation tools that take over your screen, Codex works in the background using task-specific Chrome tab groups.

This enables real parallelism.

Codex can:

• Open multiple documentation pages simultaneously
• Compare services or APIs
• Validate workflows across tabs
• Research information in parallel

And it does this while users continue working normally in their own tabs.

OpenAI also made the process reviewable. After completing a task, Codex leaves its tab groups open so users can inspect what it did, what pages it accessed, and how it reached conclusions.

That auditability could become important for enterprise adoption.

4. Integrated DevTools access

For developers, the biggest feature may be Chrome DevTools integration.

Codex can now interact directly with browser internals, giving it visibility into:

• DOM structure
• Console errors
• Network requests
• Performance traces
• Lighthouse audits

This dramatically changes debugging workflows.

For example, Codex can:

1. Detect a failing UI interaction
2. Inspect the DOM
3. Identify the underlying JavaScript or CSS issue
4. Trace the related source code
5. Suggest a fix in the IDE

Instead of relying on screenshots or copied console logs, the AI can directly observe the browser state in real time.

This pushes Codex beyond autocomplete into autonomous debugging and testing.

5. Persistent goals With /goal

The extension launched alongside a new persistent /goal system that enables longer-running autonomous tasks. (mindstudio.ai)

Rather than stopping after every action, Codex can continue working toward a high-level objective across multiple steps.

For example:

“Find the bug in the staging login flow and update the Jira ticket.”

Codex can then:

• Navigate the staging app
• Switch tabs
• Inspect DevTools
• Review logs
• Open Jira
• Update the issue
• Continue iterating until the task is complete

This persistent execution model moves Codex closer to a true software agent rather than a step-by-step assistant.

6. Human-in-the-loop security

Giving AI access to authenticated browser sessions creates obvious security risks, so OpenAI implemented permission-on-demand controls.

Codex must explicitly request permission before:

• Accessing new domains
• Reading browser history
• Uploading files
• Downloading files

Users can approve actions once, permanently allow domains, or block access entirely.

OpenAI also warns that websites should be treated as untrusted input because malicious pages could attempt prompt injection attacks against the agent.

The bigger picture

The real significance of the Codex Chrome extension is not that it can click buttons in a browser.

It’s that OpenAI is building a system capable of fluidly moving between APIs, browsers, DevTools, IDEs, and long-running workflows.

The browser is becoming more than a user interface.

It’s becoming an execution environment for AI agents.

Google AI Studio just keeps ascending toward unbelievable heights…

From a simple prompt playground for basic AI testing…

To a practical development environment for building apps, interfaces, and AI-powered products faster.

With incredible features like prompt autocomplete, visual editing, and integrated sophisticated image generation, we developers can now rapidly move from idea to prototype faster than ever.

1. Tab Tab Tab: Prompt autocomplete

The “tab tab tab” prompt autocomplete feature helps developers expand rough ideas into stronger prompts instantly. Instead of writing a detailed prompt from scratch, a developer can start with something like:

“Create a clean SaaS dashboard with analytics cards…”

AI Studio can then suggest layout details, styling direction, responsiveness, components, and user flows.

This turns prompting into something closer to code autocomplete. It speeds up brainstorming, UI generation, front-end scaffolding, and MVP creation. Developers can quickly generate a React-style structure, landing page, dashboard, or app layout, then export and customize the code further.

For solo founders and indie hackers, this is especially useful because it reduces the time spent on boilerplate HTML, CSS, and basic UI structure.

2. Design previews

Design previews let developers choose the visual direction of an app before it’s finished.

In Google AI Studio’s vibe coding experience, Gemini can now generate custom themes while your app is being created.

Within seconds, developers can compare different looks and pick the one that best fits the product: minimal, playful, premium, futuristic, enterprise-ready, or creator-focused.

For SaaS builders this means landing pages, dashboards, and MVPs no longer have to start with a generic “AI-generated” look. You can establish a stronger visual identity from the beginning, then refine the code later.

3. Edit mode and annotation

Edit mode makes transforms AI studio from a chatbot into a full-blown visual development tool.

With annotation, developers can draw directly on the app interface. They can circle a section, mark an area, or point to a component and write notes such as:

“Make this bigger,” “move this to the top,” or “reduce the spacing here.”

The AI interprets the visual instruction and updates the app accordingly.

This is a major improvement because many UI changes are easier to show than explain. Instead of writing long prompts to describe a design problem, developers can communicate visually.

This brings AI Studio closer to tools like Figma, but with code generation and AI assistance built in.

4. Integrated image generation with Nano Banana

Nano Banana integration solves one of the most common developer problems: creating visual assets.

AI Studio can now generate custom images, logos, icons, illustrations, and UI graphics while the app is being built. This removes the need to search for placeholder images, icon packs, or temporary “programmer art.”

Even better, the generated assets can maintain a consistent aesthetic across the project. Colors, style, tone, and visual language can remain aligned from the landing page to icons and illustrations.

For developers building SaaS products this means they can create beautiful marketing pages and more polished MVPs without needing a designer at the earliest stage.

These features compress the product-building workflow. Developers can prompt an idea, preview the design, annotate changes, directly edit components, generate matching assets, and export code.

That makes Google AI Studio increasingly useful for rapid prototyping, MVP development, SaaS landing pages, and front-end experimentation. It helps developers spend less time fighting boilerplate and more time turning ideas into working products.

High-quality AI coding in 2026 has gone way past just picking a good model and calling it a day.

There’s now much more that needs to be properly calibrated and fine-tuned to get the very best results from your agent.

We now have Skills which let you precisely shape AI behavior by packaging instructions, scripts, and context into reusable units.

And that’s what the new, wildly popular “Karpathy Skills” have been able to take advantage of to the fullest extent.

Karpathy Skills is a set of strict rules and guidelines that drastically improve the accuracy and reliability of your agent, once you add them to your CLAUDE.md (or CURSOR.md) file.

Let’s take a look at some of these key rules, so you can better understand why it makes such a massive difference.

1. The surgical strike

Most LLMs try to be helpful. Too helpful.

You’ve probably experienced this:

You ask for a fix or new feature.
They make the changes… but also:

• clean up unrelated code
• reformat files
• rename variables
• refactor “while they’re there”

It looks productive. But it leads to low model trust and messes up your mental model of the codebase.

The rule:

• Only change the exact lines required
• No drive-by edits
• No unrelated improvements

Why it matters:

• Prevents diff bloat
• Makes PRs readable
• Reduces hidden risk

Think about review time.

• 500-line diff → slow, error-prone
• 5-line diff → fast, obvious

This isn’t about style.
It’s about trust.

A good AI agent doesn’t try to improve everything.
It solves exactly the problem.

2. Extreme disambiguation

Most agents are optimized to continue.

If they’re 80% sure, they guess the missing 20% and move forward.

That’s dangerous.

The rule:

• Don’t assume
• Don’t hide confusion
• Surface tradeoffs

In practice:

• Ask clarifying questions
• Present multiple interpretations
• Push back on unclear requests

Why it matters:

• Prevents hallucinated requirements
• Exposes ambiguity early
• Creates tighter feedback loops

Bad agent:

“Sure, I implemented it.”

Good agent:

“Do you want A or B? They have different tradeoffs.”

3. Goal-first thinking (declarative over imperative)

Most developers naturally give instructions.
AI works better with outcomes.

The Karpathy-style rule is simple:

• Define success criteria
• Loop until verified
• Transform imperative tasks into verifiable goals

This pushes the agent into goal-first thinking.

What this changes

Instead of telling the AI what to do step-by-step, you tell it:

• what should fail
• what should pass
• how to know it’s done

That’s declarative thinking.

Imperative vs declarative

Imperative (weak):

“Add validation to this endpoint.”

Declarative (strong):

“Write a test that fails when invalid input is accepted. Update the code until the test passes.”

Notice the difference:

• Imperative → action
• Declarative → outcome

4. Anti–future-proofing (simplicity first)

AI loves to over-engineer.

You ask for something simple.
It builds something “flexible.”

Suddenly you have:

• abstractions
• configuration layers
• unused hooks
• “just in case” logic

The rule:

• If 200 lines could be 50, rewrite it
• No abstractions for single use

Why it matters:

• Prevents AI slop
• Keeps code readable
• Reduces long-term maintenance

Over-engineering compounds.

• One abstraction → pattern
• Pattern → everywhere
• Everywhere → hard to change

Simplicity doesn’t mean naive.
It means appropriate.

If the problem is small, the solution should be small.

The takeaway

No new architecture.
No breakthrough model.

Just constraints:

• Keep diffs small
• Surface ambiguity
• Define success with tests
• Prefer simple code

Claude Skills give structure to these ideas.
Karpathy-style rules give them teeth.

The result:

Not an AI that writes everything — a reliable AI that writes just enough, and just right.

One you can trust in a real codebase.

Many people thought thinking was something only possible in text generation — but ChatGPT Images 2.0 just blew that notion out of the water.

ChatGPT just became the first ever image generator to actual think and reason during image generation.

And this takes its image generation potential absolutely through the roof — the internet has been going wild in the past few days over unbelievably realistic images this thing has been spitting out.

From regular one-shot image generation to a more deliberate visual workflow: planning, editing, typography, layout, and production-style output inside ChatGPT.

1. Reasoning changes everything

With images with thinking, ChatGPT can treat a prompt like a design brief. Instead of immediately generating an image, it can plan the layout first: what goes where, which objects need to stay visible, and which details cannot be dropped.

And this solves a classic AI image problem of forgetting for more detailed prompts too.

Ask for a blue bottle, a succulent, a marble table, and a 45-degree camera angle, and older models might lose one of those details. Images 2.0 is better at mapping those pieces spatially before producing the final image.

The benefits are clear:

• Fewer missing objects
• Better scene structure
• Stronger prompt fidelity
• More accurate placement
• Less visual drift

2. Text rendering just got so much more accurate

Text used to expose AI images instantly. Posters looked good until the headline turned into nonsense. UI mockups looked convincing until the buttons became blurry fake words.

OpenAI has been making efforts to improve that in recent months — Images 2.0 is on a whole different level now.

It can handle:

• Full sentences
• Paragraphs
• Labels
• Signs
• Posters
• Menus
• UI copy
• Multilingual text

It was already improving before. But this is much better.

Now text can be functional, not just decorative. A poster can say what it is supposed to say. A label can be readable. An app mockup can include real interface text.

It can also generate functional QR codes embedded in graphics when prompted correctly, though they should always be tested before use.

3. Contextual editing is much more precise

Editing fidelity is another major jump.

Previously, if you liked an image and asked for one small change, the model might rebuild everything. “Move the logo to the top right” could suddenly change the lighting, the subject, and the whole composition.

Images 2.0 is better at keeping the image stable while changing only what you asked for.

You can request:

• Move the logo
• Change the lighting
• Replace the background
• Add a headline
• Adjust the camera angle
• Keep the character consistent

This creates a “keep 95%, change 5%” workflow. That matters because real creative work is iterative.

4. Professional-grade output

Images 2.0 also raises the quality ceiling.

It supports higher-resolution outputs, including 2K / QHD-style formats such as 2560×1440. Flexible sizes are supported too, with the long edge below 3840 pixels, total pixels capped at 8,294,400, and both edges needing to be multiples of 16.

Higher resolution helps with:

• Skin pores
• Fabric texture
• Glass reflections
• Small icons
• Fine typography
• Cleaner edges

It is also stronger at multi-panel compositions: comic strips, manga pages, magazine spreads, posters, product grids, character sheets, and explainers.

That requires consistency — characters need to stay recognizable, panels need to connect, and text needs to remain readable.

Images 2.0 is much closer to that.

5. Web-informed accuracy

Because Images 2.0 sits inside ChatGPT, it can benefit from search, files, and reasoning before generation.

That makes it stronger for prompts that need real-world accuracy.

Instead of asking for something vaguely “vintage,” you can ask for a historically accurate 1920s medical kit. ChatGPT can use references to check what objects, materials, and visual details fit the era.

This helps with:

• Historical scenes
• Product mockups
• Educational diagrams
• Architecture
• Fashion references
• Technical explainers

It still needs human checking, especially for facts, dates, prices, medical details, logos, maps, and QR codes.

ChatGPT Images 2.0 matters because it improves control:

• Thinking mode
• Better prompt fidelity
• Stronger text rendering
• Precise contextual editing
• Higher-resolution output
• Multi-panel consistency
• Web-informed accuracy

The old workflow was: write a prompt, generate, hope.

The new workflow is: describe the outcome, let ChatGPT reason through the image, generate a usable draft, then edit it precisely.

This is really happening.

ChatGPT Images is becoming a visual thinking tool.

This was such a massive upgrade.

OpenAI saw all the craze going on with Opus 4.7 — so of course they had to quickly release a new model to steal back the spotlight.

And these are some pretty incredible upgrades over GPT-5.4 we got here — no developer should ignore this.

Like now it’s gotten sooo much better at processing extremely long context — more than 50% increase for very large inputs — something that will be very useful in development, for those humongous, intricately connected codebases.

GPT-5.5 doesn’t just extend context to 1 million tokens—it stays sharper inside it, improving Graphwalks BFS accuracy from 92.1% to 94.8% at 0–128K tokens and from 48.3% to 73.7% at 256K tokens.

It even comes with a new overpowered thinking mode and a new Pro variant — to build the most complicated features, and deal with the hardest bugs known to man.

1. Massive upgrades in long-context reliability

Many models advertise huge context windows. Few stay accurate when that context becomes truly massive.

GPT-5.5 ships with a 1 million token context window and a 200,000 token output limit — but the real story is measurable reliability at extreme scale.

On Graphwalks BFS, a benchmark that tests whether the model can follow chains of logic scattered across very large documents, GPT-5.5 shows major gains over GPT-5.4 as context size increases:

• At 0–128K tokens, GPT-5.5 scored 94.8%, up from 92.1% for GPT-5.4 (+2.7 points)
• At 256K tokens, GPT-5.5 scored 73.7%, up from 48.3% (+25.4 points)
• At the full 1 million token context, GPT-5.5 scored 45.4%, up from 21.4% (+24.0 points)

Those numbers matter because most models degrade sharply as context expands.

GPT-5.5 appears significantly better at retaining signal, tracing relationships, and reasoning across huge inputs.

For us developers that means stronger performance across:

• large monorepos
• architecture documentation
• multi-service dependency maps
• long debugging sessions
• logs, tickets, specs, and tests in one thread
• research across many files simultaneously

Instead of splitting work into small prompt chunks, teams can increasingly provide broader system context and let the model reason globally.

2. Incredible agentic coding and terminal use improvements

GPT-5.5 is heavy optimized for autonomous coding, tool use, debugging, and multi-step execution.

On Terminal-Bench 2.0, GPT-5.5 reportedly scored 82.7% compared with:

• GPT-5.4 at 75.1%
• Claude Opus 4.7 at 69.4%
• Gemini 3.1 Pro at 68.5%

That is a 7.6-point jump over GPT-5.4.

And this will reflect in how we developers actually work:

• inspect files
• run commands
• read errors
• patch code
• rerun tests
• iterate until fixed

On SWE-Bench Pro (Public), GPT-5.5 scored 58.6%, versus 57.7% for GPT-5.4 and 54.2% for Gemini 3.1 Pro.

3. Overpowered thinking mode: xhigh

One of the most exciting additions is a new super-powered thinking mode in GPT-5.5’s reasoning control system.

Developers can choose among these five effort levels:

• none
• low
• medium
• high
• xhigh

xhigh is effectively the “use more compute and think harder” mode, ideal for:

• architecture decisions
• subtle debugging
• security reviews
• algorithm design
• migrations
• complex planning

Instead of using maximum reasoning for every task, teams can reserve deep thinking for problems where mistakes are costly.

4. GPT-5.5 Pro variant

OpenAI also introduced GPT-5.5 Pro, aimed at users who want maximum performance.

Listed pricing:

• GPT-5.5: $5 input / $30 output per million tokens
• GPT-5.5 Pro: $30 input / $180 output per million tokens

That means Pro costs 6x more on input and 6x more on output, strongly suggesting it is designed for:

• enterprise automation
• mission-critical engineering workflows
• legal or finance review systems
• advanced research pipelines
• premium coding agents

Standard GPT-5.5 is the workhorse for everyday tasks. Pro is the high-confidence tier.

5. Greater conciseness, efficiency, and real-world speed

One of the most underrated GPT-5.5 upgrades is not raw intelligence—it is how efficiently that intelligence is delivered.

Instead of solving coding tasks with long explanations and bloated outputs, GPT-5.5 is optimized for tighter, cleaner responses that reduce both latency and cost.

In side-by-side coding tasks, GPT-5.5 reportedly uses 72% fewer output tokens than Claude Opus 4.7 to solve the same GitHub issues. Rather than generating essays, it tends to prefer concise diffs and direct fixes.

Against the previous generation, GPT-5.5 also shows stronger internal efficiency. On standard software engineering workloads (Expert-SWE), it reportedly completes tasks using 15–20% fewer tokens than GPT-5.4.

That matters because fewer tokens compound into practical gains:

• lower API cost per task
• faster iteration loops
• cleaner patches and diffs
• easier review cycles
• less noise for developers to parse

The speed gains are equally meaningful. Because GPT-5.5 generates fewer tokens while maintaining roughly GPT-5.4-level per-token latency, it can complete the same coding workloads around 40% faster in real-world use.

For developers, that means less waiting, less clutter, and more usable output.

GPT-5.5 isn’t just a routine upgrade. OpenAI is really focusing on the real pain points serious users feel every day:

• unreliable long context
• weak autonomous tool use
• shallow reasoning on hard tasks
• expensive verbosity
• lack of premium capability tiers

The result is a model that feels even more like a serious engineering collaborator.

For developers, this may be the most important upgrade of all.

Unbelievable. Just unbelievable.

If you heard even a slice of all the crazy things that Claude Mythos has been doing in the wild — then you’ll understand why this was far far from just another incremental upgrade.

Because this is basically Claude Mythos — but actually made less powerful on purpose to avoid serious problems(!!)

Every ability went up drastically — this is hands-down the best (publicly available) coding model in the world right now. It’s not even close.

Imagine going from 54.5% to 98.5% in a major ability in just one release? How is that even possible.

For the computer-use work that sits at the heart of XBOW’s autonomous penetration testing, the new Claude Opus 4.7 is a step change: 98.5% on our visual-acuity benchmark versus 54.5% for Opus 4.6. Our single biggest Opus pain point effectively disappeared…

And should we talk about Claude Design? The shocking new Claude Opus 4.7-powered tool for creating any interactive diagram or slide from a text prompt…

1. Claude Mythos-lite

It’s been the absolute talk of the town in the days leading up this new Opus.

Earlier this month Anthropic revealed Claude Mythos Preview — an internal cybersecurity-focused model with capabilities too sensitive for broad public release.

Mythos could identify and exploit zero-day vulnerabilities across major operating systems and browsers. It reportedly found bugs 10 to 20 years old, including a 27-year-old OpenBSD vulnerability.

It also posted striking benchmark numbers:

• 83.1% on CyberGym vulnerability reproduction
• 595 crashes on internal exploit benchmarks
• 10 tier-5 control-flow hijacks on patched targets

“Mythos Preview identifies and exploits zero-day vulnerabilities across every major operating system and browser family.”

Mythos access was restricted to select defensive organizations through Project Glasswing.

Opus 4.7 is effectively the “safe” version — Anthropic intentionally nerfed its hacking capabilities while keeping its reasoning and coding skills at a “frontier” level for the public

2. Massive gains in agentic coding

It’s gotten so much better at reasoning across tasks, use tools, fix mistakes, and continue working until the objective is complete.

And self-verifying its own work too.

“Opus 4.7 pays closer attention to your instructions and devises ways to verify its own outputs before reporting back.”

That means stronger behavior such as:

• Writing tests before finalizing code
• Catching failed assumptions
• Revising broken implementations
• Managing multi-step workflows

So many companies have already been talking about all the positive impacts this has been having on their workflow.

• CursorBench: 70% vs 58% for Opus 4.6
• GitHub internal benchmark: 13% better task resolution than Opus 4.6
• Notion: +14% on complex workflows
• Bolt: up to 10% better on long app-building tasks

3. Better instruction fidelity

A subtle but important upgrade:

Opus 4.7 is more literal.

Older models often guessed what users meant. Sometimes helpful, often messy.

Opus 4.7 follows prompts more directly, making it stronger for structured engineering systems, automation pipelines, and reproducible workflows.

“Prompts written for previous models may produce different results because Opus 4.7 is less likely to infer unstated requests.”

Benefits include:

• More predictable outputs
• Less prompt drift
• Fewer hidden assumptions
• Better reliability in production

The tradeoff? Sloppy prompts may fail faster.

4. Unprecedented vision upgrades that actually matter

Anthropic also significantly improved image understanding.

Supported image resolution increased from 1,568 px to 2,576 px on the long edge, allowing Opus 4.7 to process far more visual detail.

“This is the first Claude model with high-resolution image support.”

That matters for:

• UI screenshots
• Dense dashboards
• Technical diagrams
• Multi-column PDFs
• Tables and charts

One partner benchmark reported:

• 98.5% visual acuity for Opus 4.7
• 54.5% for Opus 4.6

If you build AI tools that interact with interfaces or documents, this is a major upgrade.

5. New API controls for deeper thinking

Anthropic also changed how developers tune the model.

The headline addition is xhigh effort, a mode that trades speed for deeper reasoning.

“Anthropic recommends xhigh for most coding and agentic use cases.”

Use cases:

• Standard for light tasks
• High for serious reasoning
• xhigh for debugging large systems or complex audits

At the same time, older knobs like temperature, top_p, and top_k no longer accept custom non-default values on Opus 4.7.

That signals a new philosophy: less randomness tuning, more compute-based reasoning control.

7. The catch: tokenizer costs

Pricing stayed the same:

• $5 / million input tokens
• $25 / million output tokens

But Anthropic introduced a new tokenizer.

The same text may now use 10% to 35% more tokens than before.

“The same fixed text may tokenize to approximately 1.0x–1.35x the tokens used by Opus 4.6.”

So while rates stayed flat, real usage costs may rise — especially for long contexts, agent loops, or document-heavy workflows.

Claude Opus 4.7 is serious release for software developers.

It improves where it matters most:

• Agentic coding
• Self-verification
• Better prompt fidelity
• Stronger vision
• Deeper reasoning controls

And it arrives right after Anthropic showed a stronger model it chose not to release publicly.

That alone tells you something important:

The next generation of AI is already here.

How does this keep happening?

We haven’t even finished talking about how huge Gemma 4 is going to be…

And now we just got Qwen 3.6 35B — a new unbelievably tiny open-weight model that’s massively superior to Gemma 4 in so many crucial areas.

And it’s blown up massively — trillions of tokens processed just days after its release.

This thing absolutely destroyed Gemma 4 in several coding benchmarks — it’s not even close… wow.

And still FREE of course.

While Gemma 4 delivers a polished conversational experience, the Qwen 3.6-35B-A3B model effectively outclasses it in software engineering by solving 73.4% of real-world GitHub issues compared to Gemma’s 52.0% on the SWE-bench Verified leaderboard.

For those of you who don’t know SWE-bench is one of the most highly trusted benchmarks out there… just imagine.

And this 73.4 is so incredibly close to what Opus 4.6 scored.

Can you believe this?

This ridiculously tiny model that can run on your PC — is giving that super-computer-data-center-powered beast a dead serious run for it’s money.

Imagine how powerful this Qwen is going to be on the next release — and the next and the next…

And don’t get me started on all the other notable features like the shocking speed, the massive context… like what is this?

Gemma 4 is still struggling to get past 300K — Qwen supports a whopping 1 MILLION token context!

We’ve literally never seen an open-weight with this sort of intelligence, have this sort of processing bandwidth, it’s just incredible.

1. The most efficient model ever made

Yes — the internal design that made Gemma 4 so efficient — Qwen 3.6 takes that design to its extreme limits

It has 35 billion total parameters, but thanks to the revolutionary Mixture-of-Experts (MoE) design, it only activates 3 billion parameters per token during runtime.

Compare to Gemma 4 — that could activate 4 billion out of 26 billion parameters for its MoE model variant.

Qwen 3.6 has more total processing ability — but is much more efficient at using the exact parameters it needs to use for the task at hand.

So now you get a rare combination:

• The reasoning depth of a much larger model
• Faster inference than dense 35B models
• Lower runtime compute costs
• More realistic local deployment options

A heavyweight model without always paying heavyweight costs. “Big brain, small footprint”.

It’s really huge if you’re looking to run local workflows and save costs as a developer.

Instead of choosing between tiny fast models and giant slow models you get the awesome middle ground of Qwen.

2. Built for real coding work from the ground up

It’s not just the SWE-bench verified — Qwen 3.6 performs astonishingly in so many other coding and general AI ability benchmarks.

The upgrade over the previous version is especially notable:

• Terminal-Bench 2.0: 40.5 → 51.5
• NL2Repo: 20.5 → 29.4

All this means even better agentic capability for:

• Repository-level reasoning — understanding files, configs, and dependencies across a codebase
• Tool use — working with APIs, Python, Bash, file systems, and multi-step workflows
• Frontend workflows — generating and debugging React, UI components, CSS, and layouts

And more generally — for every aspect of software development:

• Understanding large repositories
• Editing multiple files coherently
• Fixing bugs across systems
• Using tools and terminals
• Debugging frontend issues
• Staying useful across long sessions

And so much more.

3. “Thinking preservation”

Qwen was deliberately optimized for world-class “thinking preservation”.

Most models lose their reasoning thread between turns. They forget why they made earlier decisions, repeat work, or need to re-analyze the same issue again and again.

Qwen3.6 is specifically designed to preserve reasoning context across complex conversation chains — which makes the 1 million token context window possible.

That makes a major difference for:

• Long debugging sessions
• Refactors over multiple prompts
• Multi-hour coding workflows
• Step-by-step architecture planning
• Troubleshooting where earlier context matters

4. Massive context window

Qwen3.6 technically supports a native context window of 262,144 tokens — but it’s been extended to roughly 1,010,000 tokens with sophisticated scaling methods.

That is enormous.

For us developers this means the model can potentially keep track of:

• Large repositories
• Long docs
• Logs and stack traces
• Prior conversations
• Multiple files at once
• Tool outputs and planning history

And remember: this is happening with only 3B active parameters at inference time.

It’s a technical marvel.

5. Native multimodality

This isn’t just a text model.

Qwen3.6 includes a vision encoder, meaning it can work with images and visual inputs from day one.

That opens up developer use cases like:

• Reading screenshots
• Debugging UI issues visually
• Understanding diagrams
• Parsing technical documents
• Reviewing layouts
• Frontend design workflows

Many early testers have also praised its SVG generation and visual creativity — including comparisons with proprietary frontier models in niche tasks.

This is definitely way more than just a coder

Many users are already experimenting with it on:

• Apple Silicon Macs
• Consumer NVIDIA GPUs
• High-end desktops
• Prosumer laptops

Between Gemma 4 and now this, frontier-style coding assistants just got a lot more accessible.

Qwen 3.6 35B solves several developer problems at once:

• Strong coding ability
• Efficient runtime footprint
• Long context memory
• Better agent workflows
• Visual input support
• Open weights
• Commercial-friendly Apache 2.0 license

Once again, we get to see that serious, frontier-level software agents can actually run locally and practically.

It’s be exciting to see what comes next.

This is unbelievable.

They’ve literally brought their most insane GPT models to elevate Claude Code with their incredible new Codex plugin…

Not even to replace it — but to work side-by-side and fix every possible weakness Claude could possibly have when working on your codebase.

You’re literally getting the best of both worlds now — combining the best of the best in AI coding capability into one single workflow, incredible.

And we even saw a very similar thing in the recent Cursor version 3 — it’s very clear where AI-powered software development is heading right now.

1. Proactive delegation

Definitely one of the most interesting features of this plugin.

With the plugin installed, Claude Code doesn’t have to do everything itself. It can hand off work to Codex using /codex:rescue, which acts like a built-in escalation path.

Just imagine:

• You’re working in Claude Code
• Something gets tricky—maybe a bug, maybe a messy refactor
• Codex instantly step in and take over that part

You don’t need to decide when to switch tools anymore. The system itself is structured so that one agent can call another when needed.

AI transforms from a single assistant into a full-blown coordinated team.

2. Cross-provider review

Review from a different model entirely.

Two main modes:

• /codex:review → a standard second-pass code review
• /codex:adversarial-review → a more critical, challenge-focused review

This is where things get powerful.

Instead of relying on one model’s perspective, you can:

• Write code with Claude
• Then have Codex review it independently
• Or even challenge the approach itself

That matters because different models:

• Learn from different data
• Have different blind spots
• Catch different kinds of mistakes

Now you end up getting:

• Fewer missed bugs
• More robust edge-case handling
• Better overall code quality

It’s not magic—but two perspectives are almost always stronger than one — especially in debugging and design review.

3. Hybrid runtime: local + cloud working together

Another hidden benefit.

Claude Code is very much a local, terminal-first tool. It lives in your environment, works directly with your files, and runs commands on your machine.

Codex on the other hand can operate in sandboxed environments including cloud execution.

Put them together and you get a hybrid setup:

• Claude handles local context, editing, and orchestration
• Codex can step in with isolated execution or deeper analysis

This combination gives you the best of both worlds:

• Speed and control locally
• Safety and scalability when offloading tasks

4. MCP shines yet again

None of this works smoothly without a shared way for tools to communicate.

That’s where Model Context Protocol (MCP) comes in.

Both Claude Code and Codex are built to use MCP — our now-very-standard universal interface for:

• Tools
• data access
• workflows

Because they speak the same “language,” they can:

• Share context
• Access the same tools
• Plug into the same workflows

This is what makes the integration feel natural instead of bolted on.

5. Competitive pricing: follow the strategy

There’s also a business angle here that’s hard to ignore.

OpenAI recently introduced a $100/month Pro tier, landing right in the same range as Anthropic’s Claude Max plan.

Now add the plugin into the picture:

• Developers can keep using Claude Code (Anthropic’s tool)
• But still route meaningful work through Codex (OpenAI’s system)

In other words, OpenAI doesn’t even need to win the interface.

If Codex is:

• Handling reviews
• Fixing bugs
• Running delegated tasks

…then OpenAI still captures usage, even inside a competitor’s environment.

It’s a brilliant move.

What this really means

Like I was saying we’ve already seeing this emphasis on agent composition from Cursor in their latest major IDE upgrade — and Google too of course, for their incredible Antigravity IDE.

We’re very clearly moving away from:

• “Which AI is best?”

And toward:

• “How do different AIs work together?”

No need to compare apples to oranges when you can a whole goddamn fruit salad

— Tari Ibaba (yes, me)

With this setup:

• Claude acts as the orchestrator
• Codex acts as the reviewer, challenger, or specialist

And you, the developer, are managing a multi-agent workflow instead of a single assistant.

That’s the real story here.

Not just a plugin—but the early shape of AI systems that collaborate, not compete.