Agentic coding tools have moved from a novelty to something I reach for almost daily.

Over the past year, tools like Claude Code, OpenAI Codex, and Google’s Gemini CLI have meaningfully changed how I prototype, refactor, and ship software. But as they’ve become more capable, they’ve also raised a familiar set of questions: Which tools actually help? Where do they fall down? And how much do benchmarks really matter compared to day-to-day workflow?

This piece captures what we were seeing at the beginning of 2026, a moment when agentic coding tools have been accelerating quickly but are still uneven in practice. It’s grounded in production work, structured experiments, and a lot of trial and error across different codebases. We're not trying to crown a winner. The goal is to share what’s working, what isn’t, and how agentic coding tools actually fit into the software development lifecycle.

If you haven’t tried agentic coding tools in your workflow, you should! 

Installing Claude Code, Gemini CLI, or Codex only takes a few minutes, and I think it’s a worthwhile learning and development task to develop your own opinions on these technologies.

Workflow matters more than benchmark position.

 How you prompt, model response speed, and developer experience often have more impact on productivity than raw leaderboard scores. Claude Code’s “plan mode” continues to be very helpful in real-world engineering tasks.

 most public benchmarks across reasoning, engineering tasks, and tool-use. In our testing, the new 

Gemini 3 models are multiple times faster

 than equivalent Anthropic/OpenAI models, while largely retaining output quality. However, they can struggle with planning changes out before simply jumping in to make them.

I’ve been using Claude Code and Codex extensively since around May 2025. Before that, I’d used ChatGPT regularly as an “external” pair programmer, but was apprehensive about bringing LLMs deeper into my workflow. However, with deadlines looming and a company desire to explore AI tooling, I jumped right in.

My main use in 2025 was a mix of green and brownfield work across several TypeScript applications (Svelte, React, React Native + Web) that all communicated with a PHP backend (Laravel). I found both OAI and Anthropic models to be competent and effective across the board. One thing that really stood out to me is how well they were able to operate across multiple contexts, like pulling in API data from one repo to build out a consumer in another.

This competency isn’t completely general, though. I’ve tried to use agents to generate Embedded Swift code for Playdate a few times without much luck, even given 

. They have a strong tendency to fall back to writing code that requires Foundation and other things not available in Embedded Swift. For better or worse, the farther you stray from the beaten path, the more context and hand-holding current models require. This has gotten better over time though, and I expect that trend to continue.

Agentic coding is useful at multiple points in the development lifecycle. It makes it trivial to pull in multiple libraries for quick comparisons. The models can quickly and effectively abstract existing code out into new reusable components. Given a solid existing structure, agents can be very effective at porting code, too. A coworker of mine used Claude Code to port a fairly complex Svelte app to React in an afternoon!

Agents aren’t always great at generating DRY code by default, but they can be prompted to do it. This is another area where having strong examples of code and structure you’re happy with is very helpful. Pointing the model to an existing folder and briefly explaining how new code should look relative to that folder tends to give strong results.

It’s important to recognize that things 

 go wrong! Just like with code you write yourself, sometimes the first approach isn’t right, and you need to go back to the drawing board. There are lots of ways you can make this process more iterative and less painful.

You should work using small prompts. Small prompts reduce wasted time because you can evaluate the output sooner and course correct. An LLM left to its own devices will still make a mess. Precise guidance throughout the process, instead of trying to one-shot huge chunks, helps to keep generated code organized and reusable.

Similarly, don’t be afraid to reset context. Even with plenty of context window remaining, I’ve found that current models still don’t perform well in long-running conversations. Recent versions of Claude Code actually prompt you to reset context automatically when you exit plan mode. This leaves the model with a fresh slate to reference the Markdown plan file it wrote internally.

Most agents allow you to hit escape twice to view conversation history, and roll back just the conversation or the conversation and code to a given point. This can be very useful during quick experimentation sessions when trying to find a good prompt. If a prompt gives poor results, it often becomes clear how a small additional piece of context could help direct the model correctly.

Sometimes, models might seem to just start spinning without making changes in the middle of a response. I’ve found this to be especially common with OAI models. Remember that you can always interrupt the model by pressing escape. This can help you course-correct early on or just reset a “stuck” model.

Of course, Git provides more power and flexibility than built-in tools for file history management. Stashes can be very valuable. If you’re concerned about the changes a prompt might make, a quick stash and restore beforehand can save you lots of headache.

Using the working copy as a whole or staging specific files can also be useful for injecting context into a fresh session. Prompts like “look at the staged files, which start to implement X. I’d like to continue by adding Y” often give good results.

Hopefully you already spend some time performing self-review of your commits, because that practice becomes even more important when coding with agents. I approach this like I would with any other contributor in PR review, but a huge benefit is that the feedback loop can be much tighter.

When building out a new feature, I often start by broadly determining the objects and interfaces involved. As part of this, I’ll sometimes write comments in function bodies that describe what the code will eventually do. This helps me determine how writing and working with the code will feel without too much time investment up front. This approach tends to pair well with agentic coding, because the model sees proposed interfaces along with context for how the final code is expected to flow.

One feature I really like about Claude Code is its “plan mode”. This forces the model to present a detailed plan of its work for feedback before beginning each task. The back-and-forth really makes using Claude Code feel more collaborative and less like gambling on the final output. 

, so hopefully something like this gets added to Codex and Gemini CLI soon.

If your agent doesn’t have a “plan mode”, you can get some of the benefits by explicitly asking the model to plan. For example, “I’m investigating X problem. Without changing any code, can you provide some thoughts on approach Y vs approach Z?” I’ve found this works fairly reliably with Codex, but Gemini CLI will often plow right ahead with changes even if you ask it to plan first. Your mileage may vary based on the model and toolchain you’re using. For example, I’ve heard from colleagues that Windsurf has a good Gemini-compatible plan mode.

For even larger tasks, I often find it helpful to create a temporary Markdown document describing the feature. From there, I can ask an agent to propose how to split the feature into multiple sub-tasks, each with its own document. That generated code can be edited as necessary. This lets you quickly bring new instances up to speed with an overview of the feature, and context specific to each step of implementing it.

 repository to help demonstrate the state of some common agents. The repo contains a standard 

 initialized. Full code results and additional notes are 

First, I added a high-level prompt asking to replace the stock Next homepage with results from 

. In real-world engineering tasks, I’m much more granular and collaborative with my prompting, but broad prompts are useful for relative comparison between models.

All three agents successfully completed the task. Codex and Claude Code performed about the same, finishing their work in about 12 minutes. After that, I spent around 3 minutes prompting each to fix minor bugs. Gemini was by far the fastest test, only taking 3 minutes for its work, and another ~2 minutes for bugfix prompts. This is 3x faster overall than Claude or Codex!

While all the outputs are functional, each model had similar problems: overly verbose/complex code, and bloated/disorganized components. This shows that today’s models are still struggling with wide-ranging, open-ended prompts. The given prompt tests how the model handles API integration, referencing documentation, state management, and design decisions (both in terms of UI and software architecture) all at once.

For a second test, I split the same goal up into more clearly-defined tasks across three prompt files. Lots of choices were still left to the agent, since the app is still being bootstrapped from the ground up. As expected, the discrete prompts and context reset helped produce easier to follow code across all models. Gemini impressed again, not just by easily outpacing the other models, but also by implementing every step without any feedback. This test is still very freeform, and in practice models benefit from more explicit prompts and being able to reference established patterns, as discussed above.

Right now, I’m mostly using Claude Code for professional software development tasks. However, Gemini’s speed (and the generous limits on Gemini 3 Flash) have me using it on a regular basis as well, especially for quick prototypes.

While benchmarks are great at showing relative performance of models, they don’t always accurately reflect what it’s like to use those models to ship code. Benchmarks are typically 

: the model receives a prompt and is judged on a one-and-done answer. Agentic coding tool use often doesn’t look like this. I find agentic tools at their best when used collaboratively. I clarify requirements and get things back on track throughout the process, which is lost in most benchmark methodologies.

This mismatch between synthetic benchmarks and real results makes it important to find a prompting workflow that works well for you. Agentic development is (or at least can be) highly interactive. How you prompt and the context you provide both affect how the model handles clarification, correction, and iteration.

Across nearly every major engineering, reasoning, and multimodal benchmark, 

. Their models are consistently strong on coding tasks, structured reasoning, and long-context performance. 

 where it appears, but current coverage is limited, so it’s harder to place confidently on equal footing.

The gaps between frontier models are small.

 Leaderboards frequently shift when new models or incremental updates drop, and the differences between the top contenders often fall within the margin of error. There is no clear, persistent winner.

If you're satisfied with the results you're getting from your current tooling, you’re likely not missing out on game-changing improvements by switching providers. Optimization and workflow design often matter more than the choice of a frontier model. For example, many developers find Claude Code's interface and plan mode to be more important than a few theoretical benchmark points.

“More thinking” (High reasoning modes, longer chain-of-thought) doesn’t reliably improve performance

Many models now offer “high reasoning” or “enhanced thinking” modes, but these settings don’t consistently produce better results in real-world tasks. High reasoning modes can 

dramatically increase token use and slow down output speed

. In some benchmarks, they actually perform worse. For example, GPT-5.1 Low outperforms GPT-5.1 High in the 

In practice, I find it best to only try higher reasoning modes when the model is struggling. When I do use enhanced reasoning, I typically combine it with more detailed starter prompts. Providing better initial context in my prompts (such as referencing specific files, lines, commits, or patterns) is often a faster way to a solution than switching on “thinking” at all. Claude Code provides convenient toggles for this: You can use a separate model in plan mode than when accepting edits, and in addition, you can toggle “thinking” on for each individual prompt.

Similarly, purpose-built model variants aren’t always a guaranteed win. 

Non-codex GPT models sometimes match or outperform their coding-optimized counterparts

medium have identical scores on SWE-bench Verified and Bash Only, but the 

These leaderboards are worth keeping an eye on because they focus on real engineering tasks, update frequently, and provide a clearer picture of practical model performance than general-purpose AI rankings. They won’t tell you everything about how a model behaves in your workflow, but they’re good signals for which models are currently strong and where their strengths lie.

most consistently updated engineering benchmarks

Focuses on real GitHub issues and patches. Python codebases.

screenshots, diagrams, mockups, and error messages 

LLMs acting as dev assistants across visual artifacts

 note that models are not yet equally strong across all languages: 

Users submit a single prompt to multiple models, and vote on their preferred output.

Distributed runs from users of the Repo Prompt app.

Evaluates LLM coding performance given a high level goal instead of explicit tasks like GitHub issues.

Pits human solutions against LLM solutions. Currently, 

Slightly outdated, but well-presented, and shows how much the cost can vary between models.

Many different evaluations. Basics like general intelligence, speed, and price, along with more specific investigations into agentic performance, image/video/speech generation, and more.

Evaluates hallucination rate when summarizing documents.

Note that top-performing LLMs from other benchmarks still hallucinate very frequently, many of them upwards of 10%!

Evaluates LLM use as a general assistant.

Measures tool calling accuracy. Important for agentic use cases.

Right now, the Metalab team is finding a lot of value in Claude Code, especially because of its robust plan mode. However, the AI landscape is still changing very quickly, and Gemini’s speed makes it a very strong contender.

The real advantage comes from experimenting and staying close to how these tools behave in practice. That’s exactly what we’re doing at Zero, Metalab’s in-house R&D team, where we pressure-test emerging tools long before they become defaults. Expect more from us in this space as we continue to dig into the work. And if you want to chat more about where this space is heading, send us a note.

The State of Coding Agents for 2026