Staying Relevant: How I Use Exa and Agents to Track the AI Tools Landscape

Obligatory Legal-ish Disclaimer: The views expressed here are entirely my own and absolutely do not reflect those of my employer. Also, full disclosure: I used various AI models to generate, iterate on, and massage this content because it’s 2026 and that’s just what we do now. I make exactly zero claims about its objective accuracy. Trust the robots at your own risk!

Trying to stay up to date and relevant in this industry is a daily practice. Every morning, I use Exa search along with various AI agents and models to help me digest and understand exactly what is going on in the AI developer tooling space.

Looking at just the last seven days, the answer to what changed is: a lot. Cursor shipped always-on background agents, Microsoft announced a Claude-powered autonomous agent for Microsoft 365, a major survey confirmed that 95% of developers now use AI weekly, and the tooling landscape continues to fragment in ways that make it genuinely hard to know what you should be using.

Here’s what matters, what doesn’t, and how to think about all of it without losing your mind.

This Week’s Headlines

Cursor Automations: Agents That Never Sleep

On March 5, Cursor launched Automations — event-driven AI agents that trigger automatically from external events instead of waiting for you to type a prompt. A Slack message about a bug spins up an investigation agent. A merged GitHub PR kicks off a code review. A PagerDuty incident triggers an automated response. You can even set agents on cron-like timers.

This is a meaningful shift. The prompt-and-wait loop that defines most AI coding today is being replaced by always-on background agents running in cloud sandboxes — no IDE open required. Cursor reportedly runs hundreds of automations per hour internally. According to TechCrunch (citing Bloomberg), Cursor’s parent company Anysphere surpassed $2 billion in annualized revenue in February 2026, doubling from $1 billion ARR in November 2025.

The practical implication: we’re moving from “developer uses AI tool” to “developer configures AI policies.” Instead of micromanaging individual agent invocations, you define triggers, guardrails, and review points — then let agents execute autonomously. It’s the difference between driving a car and programming a self-driving route.

Microsoft Announces Claude-Powered “Copilot Cowork”

On March 9, Microsoft announced Copilot Cowork, an autonomous AI agent built in collaboration with Anthropic as part of “Wave 3” of Microsoft 365 Copilot. Copilot Cowork can handle long-running, multi-step workplace tasks — think drafting documents, analyzing data across apps, managing workflows — powered by Claude’s models.

This is a Microsoft 365 feature, not a GitHub Copilot feature. That distinction matters and I’ll unpack the confusion below.

The Pragmatic Engineer Survey: AI Is Now the Baseline

The Pragmatic Engineer published their latest AI tooling survey on March 7, polling 906 software engineers (median experience: 11–15 years). The numbers are unambiguous:

• 95% use AI tools weekly or more
• 75% use AI for at least half their engineering work
• 56% use it for 70%+ of their work

These aren’t early adopters. This is the entire profession. If you’re not using AI tools regularly, you’re in the 5% — and that gap is widening fast.

Disambiguating the AI Coding Tool Landscape

This is the part that drives people crazy. The naming is confusing, the capabilities overlap, and every tool seems to announce a game-changing feature every other week. Let me break down what’s actually different about each one.

GitHub Copilot (Free – $39/mo)

What it is: An AI coding assistant that lives inside your existing editor — VS Code, JetBrains, Neovim, Xcode. It’s a plugin, not a separate application.

Pricing tiers (per GitHub Docs):

• Free — 2,000 completions/mo, 50 chat messages/mo. Great for trying it out.
• Pro ($10/mo) — Unlimited completions, 300 premium requests/mo, access to multiple models, coding agent.
• Pro+ ($39/mo) — 1,500 premium requests/mo, access to every available model including the latest Claude and GPT releases.
• Business ($19/user/mo) and Enterprise ($39/user/mo) for organizations.

Key distinction: Copilot is deeply integrated with the GitHub ecosystem. It can assign issues to an AI coding agent (@copilot), open PRs autonomously, read your repo’s custom instructions, and use MCP servers for external context. The coding agent runs in GitHub Actions sandboxes with full CI/CD integration.

Three modes in VS Code:

• Ask Mode — Read-only Q&A. Explain code, search docs, no files modified.
• Edit Mode — Surgical, focused changes. Rename a variable, add error handling.
• Agent Mode — Multi-step autonomous work. Refactor a module, update call sites, add tests.

Multi-model support: You can route tasks to GPT, Claude, or Gemini depending on the job. Pick the model via the model picker in chat. I’ll explain how this works with Claude specifically in the next section.

Best for: Developers who live in VS Code and GitHub, want AI that understands their repo’s conventions (via .github/copilot-instructions.md), and prefer the assistant to work within their existing workflow rather than replacing it.

Important clarification: “VS Code Copilot Chat” and “GitHub Copilot Chat” are the same thing — it’s GitHub Copilot’s chat interface running inside VS Code. There’s no separate product. GitHub Copilot is the product; VS Code is one of several editors it supports.

Cursor ($20/mo Pro)

What it is: A standalone AI-native IDE (forked from VS Code). The entire editor is designed around AI interaction from the ground up.

Key distinction: Cursor treats AI as a first-class citizen of the editor, not a bolted-on plugin. Tab completion, inline editing, multi-file refactoring, and now Automations are all deeply woven into the editing experience. With this week’s Automations launch, Cursor is pushing into autonomous background agents that don’t require the IDE to be open at all. As of March 2026, Cursor has roughly 25% of generative AI coding clients according to Ramp spending data cited by TechCrunch.

Standout features:

• Composer — Multi-file editing with full codebase awareness
• Automations — Event-driven agents triggered by Slack, GitHub, PagerDuty, timers
• Multi-model — Supports Claude, GPT, Gemini, and others; you pick per task
• Privacy mode — Code isn’t stored on Cursor’s servers (on Business plan)

Best for: Developers who want the most aggressive AI integration possible and don’t mind switching from stock VS Code to a fork. Power users who want to set up automated agents that work in the background.

Honest tradeoff: You’re tied to Cursor’s fork of VS Code. Extension compatibility is high but not 100%. Your settings, themes, and muscle memory mostly transfer, but you’re locked into their release cadence, not Microsoft’s.

Claude Code ($20/mo Pro, $100–200/mo Max)

What it is: A terminal-based AI coding agent from Anthropic. Not an IDE — it runs in your shell.

Pricing (per Anthropic): Claude Code is included with Claude Pro ($20/mo), Max 5x ($100/mo), and Max 20x ($200/mo). The Pro plan works but power users will hit usage limits during long coding sessions; Max is where Claude Code really shines for sustained work.

Key distinction: Claude Code is the most “agentic” of the bunch. You give it a task, it plans a multi-step approach, reads your codebase, makes changes across files, runs your tests, and can open a PR — all from the command line. It’s like having an autonomous contractor rather than a pair programmer.

Standout features:

• 200K token context window (Sonnet) or 1M tokens (Opus 4.6) — Can hold massive codebases in context
• True agentic workflow — Plans, executes, iterates without hand-holding
• Terminal-native — Works alongside your existing tools (git, npm, cargo, whatever)
• No IDE lock-in — Use whatever editor you want; Claude Code works alongside it

Best for: Senior developers comfortable in the terminal who want to hand off well-scoped tasks and come back to finished work. Particularly strong for large refactors, codebase migrations, and tasks that span many files.

Honest tradeoff: The terminal UX is polarizing. No inline code highlighting, no visual diffs in the tool itself. You review results in your editor of choice. The $20/mo Pro plan has usage limits that heavy users hit regularly.

Windsurf (Free for individuals)

What it is: Another AI-native IDE (also a VS Code fork), differentiated by being free for individual developers and by its “Cascade” agent that maintains persistent context across sessions.

Key distinction: Free individual tier with enterprise-grade features. Windsurf’s Cascade feature provides multi-step agentic workflows with persistent memory, meaning the agent remembers context from previous sessions.

Best for: Developers who want to try AI-native editing without paying for Cursor, or teams evaluating AI IDEs before committing budget.

Honest tradeoff and messy history: Windsurf (formerly Codeium) has had a turbulent year. OpenAI agreed to acquire Windsurf for $3 billion in May 2025, but the deal collapsed in July 2025 — reportedly because Microsoft blocked it. In the aftermath, Windsurf’s CEO Varun Mohan and co-founder Douglas Chen left for Google DeepMind, and Google secured a $2.4 billion non-exclusive technology license. Windsurf continues operating independently, but the leadership upheaval and unclear strategic direction are worth considering before betting your workflow on it.

Quick Comparison

	GitHub Copilot	Cursor	Claude Code	Windsurf
Type	IDE plugin	AI-native IDE	Terminal agent	AI-native IDE
Price	Free–$39/mo	$20/mo Pro	$20–200/mo	Free (individuals)
Editor	VS Code, JetBrains, etc.	VS Code fork	Any (terminal)	VS Code fork
Agentic	Yes (coding agent)	Yes (Automations)	Yes (native)	Yes (Cascade)
Background agents	Yes (GitHub Actions)	Yes (cloud sandbox)	No (interactive)	No
Multi-model	GPT, Claude, Gemini	Claude, GPT, Gemini	Claude only	Multiple
Best strength	GitHub integration	AI-first UX	Deep autonomy	Free tier

What I Actually Use

I use GitHub Copilot in VS Code as my daily driver. The GitHub ecosystem integration — custom instructions, MCP servers, the coding agent that opens PRs from issues — fits how I work. I have .github/copilot-instructions.md configured with my project conventions, MCP servers for external context, and custom agent modes for different tasks (writing blog posts, reviewing code, Rust learning). The multi-model support means I can route to Claude when I want deeper analysis and GPT when I want speed.

I also use Claude Code for specific tasks: large refactors, codebase exploration, and anything where I want to hand off a well-scoped task and come back to a finished result. The two tools complement each other rather than compete.

Wait, Claude Is Everywhere Now? Untangling the Microsoft–Anthropic Confusion

This is the thing that’s confusing everyone right now, and for good reason. In the span of one week, we got headlines about:

• Claude models inside GitHub Copilot
• Microsoft’s “Copilot Cowork” powered by Anthropic
• Claude Code as Anthropic’s own standalone product
• Microsoft being OpenAI’s biggest investor while simultaneously buying Claude

Let me untangle this. There are three completely separate things happening with the word “Claude” in developer tooling right now:

1. Claude Models Inside GitHub Copilot (Model Picker)

Since October 2024, GitHub Copilot has offered multi-model support. You’re not locked into OpenAI’s models. In VS Code, you click the model picker in the Copilot Chat panel and choose from available models — including Claude.

As of March 2026, the Claude models available in Copilot include Claude Sonnet 4.6 (GA as of February 17, 2026) and Claude Opus 4.1. Older models like Claude Sonnet 3.7 and Opus 4 were deprecated in October 2025. This applies to Copilot Chat in all modes (Ask, Edit, Agent) and across VS Code, JetBrains, github.com, and GitHub Mobile.

The practical benefit: you stay in VS Code, keep your Copilot subscription, but get Claude’s strengths (strong agentic reasoning, excellent instruction-following) without switching tools. I use Claude Sonnet 4.6 in Copilot’s Agent Mode for tasks that benefit from its planning capabilities, and GPT for fast completions.

2. Copilot Cowork (Microsoft 365, Not GitHub)

On March 9, Microsoft announced Copilot Cowork as part of “Wave 3” of Microsoft 365 Copilot. This was built in collaboration with Anthropic and is powered by Claude. It’s an autonomous agent that handles long-running workplace tasks — document drafting, data analysis across Microsoft 365 apps, workflow automation.

This is not a coding tool. It’s not part of GitHub Copilot. It’s Microsoft’s enterprise productivity AI, similar to how Claude’s own “Projects” and “Artifacts” features work but integrated into Office apps. The reason it confuses developers is that Microsoft uses the word “Copilot” for both its developer tool (GitHub Copilot) and its enterprise productivity assistant (Microsoft 365 Copilot). Different products, same branding.

The Reuters, The Verge, and Fortune coverage all reported this as a Microsoft 365 feature, not a GitHub feature.

3. Claude Code (Anthropic’s Own Product)

Claude Code is Anthropic’s standalone terminal-based coding agent. It has nothing to do with Microsoft or GitHub. You install it, run it in your terminal, and it uses your Claude subscription (Pro at $20/mo or Max at $100–200/mo). It’s a separate product from Claude-the-chatbot and from Claude-the-model-inside-Copilot.

Why This Is Confusing (and Why Microsoft Is Doing It)

Microsoft is OpenAI’s largest investor. They’re also now buying AI from Anthropic — OpenAI’s chief rival. GitHub Copilot offers Claude models alongside OpenAI models. Microsoft 365 Copilot uses Claude for its new autonomous agent feature.

This isn’t contradictory; it’s deliberate diversification. Microsoft is reducing single-vendor dependency. For developers, the upshot is simple: Claude models are available almost everywhere now — inside Copilot, inside Cursor, as a standalone product (Claude Code), and powering enterprise automation (Copilot Cowork). You don’t need to switch tools to use Claude; you just need to know which Claude integration you’re using and what it does.

The Human Struggle to Keep Up

Here’s the part nobody talks about enough.

The Pragmatic Engineer survey didn’t just show adoption numbers. It showed an industry moving so fast that even experienced engineers — people with 11–15 years of experience — are constantly reshuffling their toolkits. And the pace isn’t slowing down.

The Treadmill Problem

Every week brings something new. This week it’s Cursor Automations. Last week it was a new Claude model. Next week it’ll be something else. The natural response is to chase every announcement, try every tool, read every comparison article.

This is a trap.

You can’t stay current by consuming everything. You stay current by having a stable foundation and selectively integrating new capabilities that solve real problems in your actual workflow. The developers who are thriving aren’t the ones who use every tool — they’re the ones who deeply understand a few tools and know when to swap in something better.

Why Developers Feel Behind

Three things make this moment uniquely disorienting:

1. The tools are changing what “coding” means. Writing code line-by-line is becoming a smaller part of the job. Configuring agents, defining tool contracts, writing custom instructions, and reviewing AI-generated PRs are taking up more time. If your mental model of “being a developer” is “I write code in an editor,” the ground is shifting under you.

2. The naming is deliberately confusing. Is it “GitHub Copilot” or “VS Code Copilot Chat” or “Copilot Agent Mode”? Is Cursor an editor or an agent platform? Is Claude Code a different product from Claude? Vendors have every incentive to make their ecosystem sound comprehensive and their competitors sound limited. Cutting through the marketing takes real effort.

3. The comparison articles are already stale. By the time someone publishes a detailed comparison of Cursor vs. Copilot vs. Claude Code, at least one of those tools has shipped a major update. The half-life of a “definitive guide” is about three weeks.

How to Actually Stay Relevant

Based on what I’ve seen work — both for myself and for other engineers I talk to:

Pick a primary tool and go deep. Mastering one AI coding assistant thoroughly beats surface-level familiarity with five. Learn the keybindings, configure the custom instructions, build MCP servers, understand the model routing. Depth compounds in a way that breadth doesn’t.

Focus on engineering fundamentals that transfer. No matter which tool you use, you still need to write clear specifications, design good interfaces, review code critically, and think about reliability. These skills make you better at using AI tools, and they don’t expire when the tool landscape shifts.

Treat AI tools as infrastructure, not magic. The developers getting the best results from AI agents aren’t the ones with clever prompts. They’re the ones with well-maintained instruction files, clear project documentation, good test suites, and reproducible builds. An AI agent is only as good as the codebase it operates in.

Set a learning cadence, not a learning sprint. I spend about 30 minutes a week reading the one or two most significant announcements. If something looks genuinely useful for my workflow, I try it in a real project — not a toy example. Most weeks, the answer is “interesting, but not for me right now.” That’s fine.

Accept that you’ll always be behind on something. Nobody — not even the people building these tools — fully understands the entire landscape. The goal isn’t omniscience. It’s having a clear enough mental model that when something relevant ships, you can evaluate it quickly and integrate it if it matters.

The Real Competitive Advantage

Here’s the counterintuitive part: the developers who will come out ahead aren’t the ones who adopt every new tool fastest. They’re the ones who build the deepest understanding of how to engineer reliable systems with AI components.

That means understanding when to use Agent Mode and when Ask Mode is better. It means writing .github/copilot-instructions.md files that actually teach the agent your codebase conventions. It means configuring MCP servers so the agent has access to the right context. It means reviewing AI-generated code with the same rigor you’d apply to a junior developer’s PR.

The tools will keep changing. The engineering discipline won’t.

---

This post was informed by an Exa search of the latest AI developer tooling news from the past week (March 4–11, 2026), fact-checked against primary sources: GitHub Blog, GitHub Docs, Microsoft 365 Blog, TechCrunch, Reuters, The Verge, and Anthropic. The landscape will look different a month from now — that’s kind of the point.