Notes

To help visualize the real gap in release velocity among the three major AI labs, here is a compilation of their major model release data over the past year and a half (from 2025 to the latest in June 2026).

The numbers are quite telling. The release cadence for Anthropic and OpenAI is accelerating rapidly, whereas Google Gemini has a noticeably longer cycle for major iterations.

Here are the timelines reconstructed from actual release dates:

1. Anthropic Timeline: High-Frequency Iteration as a Routine

Anthropic has essentially turned fast-paced iterations into an automated routine, with dense releases spanning the second half of 2025 and the first half of 2026:

• February 24, 2025: Released Claude 3.7 Sonnet (introducing hybrid reasoning).
• September 29, 2025: Released Claude Sonnet 4.5 (highlighting industry-leading coding and agent capabilities).
• October 2025: Released Claude Haiku 4.5.
• November 24, 2025: Released the flagship Claude Opus 4.5.
• First Half of 2026: Conducted rapid-fire iterations within just a few months, launching Opus 4.6, Sonnet 4.6, Opus 4.7, and Opus 4.8 in quick succession.
• June 2026 (this month): Officially launched the next-generation models, Claude Fable 5 and Mythos 5.

Key Takeaway: Major releases are often separated by only a month or two. The frequency is relentless.

2. OpenAI Timeline: Steady Foundations Followed by Swift Counterattacks

OpenAI historically took longer gaps between major generations, but competitive pressure has visibly accelerated their release tempo:

• August 7, 2025: Officially released the landmark GPT-5.
• December 11, 2025: Quickly launched GPT-5.2 just four months later to counter Google’s response.
• First Half of 2026: Iteratively rolled out the GPT-5.6 Limited Preview series.

Key Takeaway: While major generations used to be spaced far apart, since the GPT-5 era, major updates and branch versions are now iterating on a monthly cadence.

3. Google Gemini Timeline: Heavy Steps and Clear Lag

In contrast, even if we count the Nano Banana series, Google’s cadence for its flagship models lags one or two steps behind:

• March 25, 2025: Released Gemini 2.5 Pro (Experimental).
• June 17, 2025: Gemini 2.5 Pro and Flash became generally available (GA).
• August 26, 2025: Publicly released Gemini 2.5 Flash Image (internal codename: Nano Banana).
• November 18, 2025: Released Gemini 3 Pro (Preview).
• December 3, 2025: Launched Gemini 3 Deep Think (Preview) to compete with reasoning models.
• February 2026: Released Gemini 3.1 Pro (Preview) and Nano Banana 2.
• May 19, 2026: Released Gemini 3.5 Flash (Preview).

Key Takeaway: While competitors are already shipping Fable 5 / Mythos 5 or GPT-5.6, Google’s latest primary offering is only at the Gemini 3.5 Preview stage. Moreover, Google’s timeline is heavily filled with “Experimental” and “Preview” labels, indicating a significantly longer cycle for actual GA major version upgrades.

Conclusion

Based on these concrete data points, the skepticism regarding Google’s pace is entirely justified. On the hard metric of release velocity, Google’s pace is visibly trailing the other two. It appears more like a chaser passively reacting to competitors rather than a leader setting the pace. This quantitative gap understandably fuels concerns over a lack of innovation or agility within the tech giant.

Referencing a great project on the side is such an effective way to level up your own. Try this:

1. Download and then chat with Codex on a reference project.
2. Distill lessons into your project docs.
3. Spin up multi-agents to execute the refactor.

How do you leverage agents?

When using the voice mode in Claude’s macOS app, selecting Chinese makes it unable to recognize English when I speak, and vice versa. It is very disappointing.

Recently, I noticed a notification in the Gemini CLI indicating that the tool is going to be retired. Since it has been an essential part of my workflow, I immediately looked for the transition path and downloaded/installed its successor: Antigravity CLI.

My very first impression of using Antigravity CLI is its speed. It is incredibly fast. The response times, execution of tasks, and overall interaction feel significantly snappier compared to my previous setup.

I look forward to integrating Antigravity deeper into my daily tasks and seeing how it helps optimize my development workflows going forward.

The Efficiency-Control Dilemma: An Uncomfortable Realization

However, this transition also brought an unexpected realization about human-AI collaboration and the boundaries of control.

During our interaction, the CLI automatically staged, committed, and pushed changes to my GitHub repository. Because I had granted permission earlier in the session, the tool executed these commands without asking for my confirmation each time. While incredibly efficient, it left me with an uncomfortable realization: I felt like I was losing control over my own workflow.

When an AI assistant has the capability to write directly to production or public repositories without an explicit “human-in-the-loop” confirmation for every action, the boundary between assistance and autonomy becomes blurred. It is a reminder that as AI tools become faster and more agentic, maintaining human agency and having absolute control over the final push remains crucial. Moving forward, establishing clear verification boundaries is just as important as optimizing for speed.

Recently, I’ve been reflecting on my journey with AI. While I consider myself a deep user compared to the average person—frequently using AI for web coding and keeping up with the latest research—I’ve realized there is still a significant gap between being a “depth” user and a true AI professional.

The Orchestration Gap

One of the most striking differences lies in orchestration capability. True experts can coordinate hundreds or even thousands of AI agents simultaneously to solve complex problems. My current workflow is much more modest, typically involving one or a few agents per hour. While effective, it lacks the massive scale and automated task decomposition that defines the “pro” level of agentic workflows.

The Efficiency Paradox

A major observation I’ve made is what I call the “Efficiency Paradox.” In the long run, AI undoubtedly increases productivity. However, in the short term, the process of building the necessary infrastructure—such as creating custom Model Context Protocol (MCP) tools and configuring specialized agents—can actually slow down immediate progress.

I’ve found myself spending significant time developing these tools to empower my agents, which sometimes conflicts with my immediate KPI-driven deliverables. This highlights a challenge in prioritization: the constant tug-of-war between investing in long-term AI leverage and fulfilling short-term delivery requirements.

Conclusion

Using AI effectively isn’t just about knowing how to prompt; it’s about understanding the trade-offs in tool building, the complexity of agent orchestration, and the discipline of prioritization. As I continue to refine my workflow, the goal is to bridge the gap between building tools and delivering results, eventually scaling my “agentic” capacity to new heights.

I recently made two discoveries that, when combined, create an incredibly effective workflow for finding bugs in software projects.

First, I created a custom AI skill that transforms the AI into a highly critical, “genius” software engineer. The goal of this persona is to scrutinize my code and identify logical flaws. By providing it with raw input data to use for validation, the AI acts as a rigorous logical reviewer and is able to find many trivial, yet extremely hard-to-catch bugs.

Second, I started utilizing the loop functionality available in tools like Claude Code, which allows the AI to run tasks automatically at set intervals, such as once every hour.

The real magic happens when combining these two capabilities. I set up the AI to act as this critical code reviewer and configured it to run on a loop every hour. By opening 7 or 8 terminal windows and running this concurrently across multiple projects, the AI executes about 7 to 8 rounds of review a day per project.

The best part is that it requires almost zero manual intervention. The AI simply runs in the background throughout the day, deeply analyzing the code. It consistently uncovers deeply hidden bugs that would otherwise be very difficult to spot. This automated, continuous review process has proven to be an exceptionally powerful and hands-off workflow for improving code quality.

Here’s a small but impactful win that perfectly illustrates the power of leveraging AI for practical, everyday tasks.

The What: The Problem

I ran into a formatting roadblock after downgrading my Protein Metrics software for a project. The older version’s Excel export was missing a blank row required before every plot for our data upload system. I was faced with a choice: either go through a tedious cycle of re-configuring settings, re-exporting, and re-analyzing the data, or manually insert hundreds of blank rows. Neither seemed like a good use of time.

The So What: The Solution & Impact

I used Microsoft Copilot to generate a VBA macro to perform this task automatically. The result:

• Saved 288 manual actions (96 plots x ~3 clicks/scrolls each).
• Avoided a time-consuming re-export and re-analysis cycle.
• Eliminated the risk of a formatting rejection due to the missing spacer rows.
• Created a reusable micro-automation that I and others can use for future files.

The Now What: The Takeaway

If you’re still performing repetitive, mechanical tasks in Excel, try prompting an AI assistant like Copilot for a macro. The first small win is crucial—it builds the muscle and confidence to make future, more complex automations feel approachable instead of overwhelming.