State of Agentic Coding Tools — March 2026

An opinionated survey of editors, coding agents, workflow wrappers, and the skills that tie them together — based on what I actually use day to day.

March 9, 2026

tldr

An opinionated snapshot of the agentic coding landscape as of March 2026, drawn from daily use rather than benchmarks.

Editors are separating from agents — and that's good. Zed is the daily driver (fast, great Vim bindings). Cursor still has the best tab-complete and is the easiest on-ramp. Plugins and IDE-native AI are becoming less relevant as agents move to the terminal.

Coding agents are where the real action is. Amp sets the gold standard in thinking and transparency — follow their Chronicle blog. Claude Code has a brilliant model but a rough product; best used through other harnesses. Codex has the best CLI + desktop combo and GPT-5.x actually reads before writing. pi is the author's main tool — minimal, four core tools, bring-your-own everything.

Workflow wrappers like Conductor and Superset are an emerging layer for managing parallel agent sessions, worktrees, and tasks. Not essential yet, but the category is real.

The most durable investment: build your own skills (reusable prompts for commits, PR reviews, Linear workflows, etc.). They travel with you across tools. Keep them around 100 lines, favor progressive disclosure, and separate core logic from integration code so plugins port easily.

Bottom line: knowing what your agent is doing is engineering; not knowing is vibe coding. Start simple, understand the fundamentals, and don't lock into one tool too early.

A common mistake I see people make is going all-in on vibe coding or agentic engineering way too fast, way too early. Committing to one tool before understanding what they actually need. I prefer to take it slower: see what others are doing, test things, iterate, and form my own opinions.

So here's what I've collected from my own experience. These opinions are mine and they might be wrong or change with time. Think of this more as a personal brain dump than a definitive guide.

One thing to keep in mind throughout all of this:

Knowing what your agent is doing is engineering. Not knowing is vibe coding.

Editors & Plugins

Editors and agentic coding tooling have started to separate, and I think that's a good thing. The value of an editor is exactly what it's always been: editing code. All your existing workflows are still valid.

The first wave of agentic coding was built on top of editors, but my gut feeling (and what I see happening in the industry) is that it's shifting. Agents are increasingly becoming teammates you manage, not features inside your IDE. Which means the editor can go back to just being an editor. The choice of which one you use is back to being about your preferences and setup, not about what AI capabilities it unlocks for you.

As for plugins, I'm generally not a fan. The integrations never feel native, the experience is off, and the workflows have changed enough that plugins don't really fit the new model anyway.

Zed

My current daily driver. Way faster than VS Code-based editors with excellent Vim bindings. You can run near-zero config or import your nvim setup directly. Solid coding agent integrations if you want them, and I'm genuinely curious where they take their collaboration features.

The team is quite open about what they're building and how they think about the future of coding. Their YouTube channel is a great resource, the Zed Decoded series in particular.

The tab complete is good enough for daily use. That said, I use Zed as an editor only. Not leveraging most of the AI features beyond the occasional "explain this" on a highlighted block.

Cursor

Still the best for editor-style coding. Tab complete is the undisputed winner, nobody comes close. Really good agent support, user-friendly UI, and you get the entire VS Code plugin ecosystem. Their blog has been a useful resource lately. For frontend work specifically, the in-app browser with agent support makes it particularly good. If you're new to agentic coding and want a batteries-included IDE, Cursor is still my recommendation.

Why I stopped using it daily: I started building my own tool stack, and as I got deeper into agentic coding the restrictions started showing. There's also the UI problem. Every update I have to re-learn where the editor mode and agent mode live. That got exhausting, especially once I started opening the IDE mainly to review and refactor work the agent had already done.

At $20/month it made sense when I was actively coding in the IDE. Now I'd rather use Zed or Vim as my editor and put that $20 toward a full Claude or Codex subscription for AI capabilities instead. Good team though, they're shipping constantly, so I'm keeping an eye on where it goes.

Copilot

A few things work in its favor: the VS Code plugin is solid, you can use multiple models, and the subscription is usable in other coding agents too. The $10/month plan is probably the best value on the market for getting started and integrating into an existing toolkit without giving up your IDE. If you want to try different LLMs without committing to a bigger subscription, it's a reasonable choice.

That said, it runs out fast under heavy agentic usage and the IDE integration still isn't at the level Cursor offers. I haven't used it in a while and wouldn't reach for it today.

nvim

Still a great editor. There are plugins that bring Cursor-like or Copilot-like functionality if you want to put the time in. I don't use it for agentic coding at all. I'm consciously trying to use fewer tools, so nvim/Vim has become the thing I use to quickly open files, make quick terminal fixes, or validate and refactor agent output. Sessions are 5-10 minutes max. If I need a deeper code review or actually want to implement something, I switch to Zed.

Augment Code

Best-in-class for context. Their proprietary source code indexer is genuinely impressive and nobody else is close. But I'm not sure it's a long-term competitive advantage. My sense is that context management is increasingly becoming the engineering team's responsibility, structuring your codebase to work well with agents, rather than something a tool handles for you.

It made more sense when I was spending most of my time in Cursor/VS Code editing code by hand. In the current setup, not so much. And honestly this tool only really shines if the whole team adopts it. Individual use doesn't make much sense. Pass from me for now.

Coding Agents / Harnesses

Coding agents (or harnesses) are pre-built agentic loops, mostly terminal-based, though some come with desktop apps that add visual feedback and workflow automation on top.

My general rule is: keep it simple, learn the fundamentals, understand what's running under the hood. I wouldn't heavily invest in building on top of one specific harness right now. The landscape is moving fast, and the products being built by dedicated teams are moving even faster. That said, Vim and Emacs still exist for a reason. There's long-term value in building your own workflows and understanding how these things work underneath, rather than just adopting whatever's popular this month.

Amp

Gold standard, in my opinion. Small team, excellent product. I follow their Chronicle blog closely. It's one of the best signals for where the top 0.1% of the industry is actually heading. They're open, transparent, and genuinely thinking hard about what the future of programming looks like. Also a good resource if you care about how to build and grow a product.

Some posts that actually changed how I think and prompted me to update my own setup:

If I had to point someone to one team and say "just follow what they're doing," it would be Amp.

Downsides: They're expensive compared to Claude or Codex subscriptions, and they don't support bringing your own API key. All inference goes through their infrastructure. So I end up using the knowledge they share to inform my own setup rather than actually using the product.

Claude Code

The underlying model (Opus 4.5/4.6) is brilliant. Very capable and fast. If you're new to agentic coding and want to get started quickly without building your own setup, it's a reasonable starting point. For the first month or two it works well enough.

But after that, problems start piling up. Too many crashes, too many bugs. You can tell it wasn't built with careful attention to edge cases or UX. The things that kept bothering me:

  • Huge system prompt with a lot you don't actually need
  • Features like agent teams, sub-agents, and parallelization baked in and always on. These should be opt-in per session, not defaults.
  • Too eager to start writing code without doing the thinking first
  • No real way to trim things down or exclude what you don't need, since the source isn't open

What I still use it for: One thing Claude Code is genuinely useful for in my current setup is running third-party plugins. Since it's the most popular agent out there, most plugins get built for Claude Code first. So when something new comes out that looks interesting, I'll run it in Claude Code for a few weeks to see if it's actually worth my time before deciding whether to build my own version or adapt it to pi.

A good example right now is Ars Contexta. I've been running it in Claude Code to get a feel for it. If it sticks, I'll figure out how to adapt it to my own workflow. As long as I have the subscription anyway, might as well use it this way.

On the positive side: the desktop app is genuinely good for research. It's replaced most of my Perplexity usage. If I want a detailed comparison or a deep report on something, Claude desktop is my go-to. The Cowork integration is also quite good. You can hand it Linear tasks, Google Docs links, drop in any file, and it runs with it.

My current stance: Keep the subscription (the model is that good), but use it via pi or opencode for day-to-day work if you can. The quality gap in the product can close fast and when it does, I might revisit.

Note on the OAuth situation: Anthropic moved in early 2026 to block third-party tools from using subscription OAuth tokens, meaning tools like OpenCode broke overnight for Claude access. Short version: if you're building on top of Claude subscriptions through third-party tools, proceed carefully and know the risks.

OpenCode

Love the UI and the workflow. You can use multiple models and switch between them, which matters a lot at this stage. The plugin architecture is solid and there's a growing ecosystem around it, including some pretty wild things people have built on top.

One notable example: oh-my-openagent, a massive harness built on top of OpenCode with aggressive parallel execution. The project's README openly acknowledges it was one reason for the widespread Claude Code account bans that happened. It was running 24/7 across multiple instances. This is why we can't have nice things.

The session handling issues and the OAuth crackdown made it hard to rely on OpenCode for Claude, which is part of why I moved on. It's also opinionated in ways that are good if you want a curated setup, but get in the way once you're trying to build your own thing.

I'd still recommend it over VS Code/Cursor/Zed for someone who wants to transition from IDE to more terminal-native, hands-off agentic engineering. You can bring your own subscription (everything except Claude Code), including Copilot. It's a natural bridge.

Codex

Best CLI and desktop app from a top-tier AI lab, in my opinion. The CLI is open source, written in Rust, and the team has been doing good things for the industry lately. They've been earning my trust over the past few months.

GPT-5.2/5.3-Codex has become my go-to for researching, reviewing, and planning. It actually tries to understand the code before doing anything, rather than going off and starting to modify things. The desktop app is also top tier.

The team is transparent about how they work and what they're building. Some good reads:

They've also figured something out with context management and caching. You can reach 60-70% of context before the agent starts falling apart, which is genuinely better than most.

The limitation for me: I'm on $20/month and can't fully leverage the longer runs and automations that a $200/month Pro subscription would unlock. Because of that I have to switch between models and tools. If you could only have one subscription and wanted to go all-in, I think the Pro plan here is currently the most logical choice.

pi

This has been my main coding agent for a while now.

It feels like the Vim of coding agents. Minimal, opinionated at its core, completely unopinionated about what you do with it. Tiny system prompt, four core tools (read, write, edit, bash), small codebase, easy to understand what's actually happening under the hood. You can bring your own subscription, and you can ask it to extend itself.

The community around it on X is active and culturally good. People building their own things and sharing them, rather than just installing preset solutions. That forces you to think about what you actually need.

My setup: github.com/cagdotin/agents, I update it almost daily. I also built a desktop app wrapper on top of it, but I'm not pursuing that further. Building a desktop app is basically a full-time job. My conclusion: terminal, tmux, and CLIs is all you need.

Downsides:

  • No guardrails or permissions by default. You need to know what you're doing.
  • Takes time to set up properly. You'll get more out of it if you've used other agents first.
  • You build everything yourself, which is the point, but it means you're responsible for everything.
  • No MCP support out of the box (I actually consider this a plus).
  • Updates for cutting-edge features are slower. If you want something, you build it rather than waiting.

Workflow Wrappers

A new category that's been gaining traction. These apps sit on top of coding agents and try to solve the coordination layer: running multiple agents in parallel, managing git worktrees across projects, tracking tasks, doing code review, without being an editor themselves.

You'll probably want these after you've been using coding agents for a while and start hitting the wall of "how do I manage five different agent sessions without losing my mind." Five tmux tabs deep into parallel conversations gets messy fast.

Conductor

conductor.build — pretty good overall. I like how they handle workspaces. The one thing that bothered me is they built their own chat interface for the agent rather than just giving you a terminal. That means if you've customized your own agent, those capabilities don't surface properly here. But if you're using Claude Code or Codex as-is, it works well.

Superset

superset.sh — I prefer the approach here. They give you the terminal by default and layer tooling on top: project and worktree management, task tracking, Linear integration, quick file diffs. It's more flexible if you're running your own setup. Open source too, which matters.

Both are worth keeping an eye on. Neither is essential yet, but the category is real and I think it'll matter more as parallel agent workflows become the norm.

Skills, Plugins & Commands

Regardless of which harness you end up with, one habit that will serve you well: build your own skills.

Skills are basically prompts you give to the agent to guide specific workflows. Reusable instructions for things you do repeatedly. Most agents support them in some form, so with the right abstraction you can port them across tools without much effort.

A few I use almost every day:

General rule of thumb: keep skills around 100 lines. If one starts growing beyond that, it's usually a sign it's trying to do too much. Break it into multiple files, or extract part of it into a script. The exception is when the skill genuinely can't be split, but that's rare.

The other thing to keep in mind is progressive disclosure. Don't dump everything into a skill upfront. Start with what the agent actually needs to know and expand from there.

Plugins are the next step. When you find yourself doing the same thing repeatedly, or realize a feature you want just doesn't exist, that's a plugin waiting to be written. Each harness has its own plugin architecture, but if you structure things well (core business logic separated from the integration layer) you can reuse the same plugin across multiple agents without rewriting it from scratch. That separation also makes it much easier to port things later when you switch tools or want to try something new.

Commands are similar to skills, but instead of the agent auto-detecting when to use them, you trigger them manually. Both are ultimately just prompts. The difference is in how they get invoked. The pattern I follow: if the agent should recognize when to use it contextually, it's a skill. If I want to call it explicitly, it's a command.

No matter what tool you're using today, the skills and prompts you write are yours. They travel with you.