10 Things Developers Want from their Agentic IDEs in 2025

Kate Holterhoff (RedMonk) · article · 2025-12-22 source ↗ Reader 🖥️

Agent Memory Agent-Native Design Agent Skills AI Unit Economics Human-in-the-Loop Long-Running & Managed Agents MCP (Model Context Protocol)Multi-Agent Orchestration Spec-Driven Development

Developer demand on AI coding tools shifted decisively in 2025 from reactive assistance (autocomplete, suggestions) to autonomous delegation across entire codebases, and this shift produces a more sophisticated, partly self-tensioned set of ten concrete demands — simultaneously wanting more autonomy (background agents, parallel orchestration) and tighter control (predictable costs, human-in-the-loop gates, rollbacks) — that agentic-IDE vendors must satisfy without losing sight of the premise that these tools exist to serve developers, not replace them.

practical · mixed — A yearly industry-analyst listicle (third installment of a RedMonk series) that is argumentative at the frame (a claimed paradigm shift from assistance to delegation) and expository in its core (a ten-item taxonomy of developer demands, each evidenced by named vendor features and practitioner quotes). RedMonk discloses a client relationship with several of the named vendors (AWS, Microsoft/GitHub, Red Hat, Tessl, Google).

Structure

Part	Role
Framing: revisiting the author's 2023/2024 'AI Code Assistants' series, renamed 'Agentic IDEs' to mark a paradigm shift	context/thesis statement
Year-over-year contrast: 2023 autocomplete -> 2024 multi-file editing -> 2025 full workflow delegation with developer confidence in results	evidence
Market survey of 2025 entrants and incumbents (Cursor, Copilot, Windsurf/Cognition, Trae, Kiro, Project Bob, Augment Code, Zencoder, JetBrains Junie, Google Antigravity, plus CLI tools Claude Code, Codex, Cline, Continue.dev, Aider, OpenDevin)	context
The List: ten named developer demands, each evidenced by specific vendor features and practitioner quotes (Addy Osmani, Simon Willison, Gergely Orosz, Denis Volkhonskiy)	evidence / core taxonomy
Looking Ahead to 2026: developer-role shift toward architecture/judgment; closing argument that tools must serve, not replace, developers; market Darwinism toward reliability and responsiveness to feedback	conclusion
Disclaimer naming RedMonk's client relationships with several vendors discussed	context (disclosure)

Key terms

Agentic IDE Agent-Native Design
An environment (not merely an assistant) in which agents reason about an entire codebase, modify multiple files, run terminal commands, execute tests, and iterate on feedback — while the developer works on something else entirely. The author's deliberate replacement for her prior term 'AI Code Assistants,' marking a shift from passive suggestion to autonomous execution.
Spec-driven development Spec-Driven Development
An approach (exemplified by Kiro, Tessl, GitHub Spec Kit) using requirements.md, design.md, and tasks.md files as a durable, shared contract that both humans and AI agents reference, surviving context-window limits and session boundaries, and serving as a checkpoint for verifying that implementation hasn't diverged from design.
Skills Agent Skills
Reusable, shareable, version-controlled modules that package a workflow (e.g., a code-review or security-audit procedure) once, for consistent reuse across projects and teams, rather than re-engineering the same prompt repeatedly — encoding institutional knowledge that new team members can adopt immediately.

Propositions

explicitDeveloper demand on AI coding tools shifted in 2025 from incremental assistance (reactive autocomplete in 2023, multi-file editing in 2024) to full-workflow delegation with developer confidence in the results — the ask moved from 'help me write this function' to 'build this feature while I review another PR.'conf: high
explicitDevelopers want 'background agents' — the ability to queue tasks for agents to complete autonomously, even overnight, and return only to review finished pull requests ('fire and forget').conf: high
explicitDevelopers increasingly expect agentic IDEs to maintain persistent memory across sessions — remembering past decisions, recognizing patterns from previous work, and functioning as a living system of record for reasoning as well as code.conf: high
explicit2025's pricing volatility (Cursor's usage-based pricing shift, Claude Code users reporting limits inconsistent with Max subscriptions, Replit's effort-based pricing cost overruns) has made transparent, predictable cost visibility — token usage per prompt, cost per session, clear limits before they're hit — a baseline developer expectation rather than a nice-to-have.conf: high
explicitMCP became, in the author's assessment, 'the fastest adopted standard RedMonk has ever seen' — reaching Docker-like adoption speed, cross-vendor support (OpenAI, Google DeepMind, Microsoft, AWS), and donation to the Linux Foundation's Agentic AI Foundation within roughly a year — to the point that developers now simply assume it will 'just work' for connecting agents to tools and data.conf: high
supportsThis Week's Best Developer Tools & Betas · p5 — Both independently observe that MCP (alongside skills and hooks) has become table-stakes, assumed infrastructure for an agentic IDE rather than a differentiating feature.
supportsAWS MCP Server Reaches GA with Full API Coverage and IAM-Based Governance · p4 — Both describe MCP's role as making vendors/agent runtimes interchangeable — developers 'assume MCP will just work' here mirrors MCP making AWS portable across agent runtimes there.
explicitMulti-agent orchestration (running multiple agents in parallel on different tasks, with dashboards to monitor, pause, redirect, or terminate them) is an emerging developer demand, but one that currently creates an accessibility gap: successful parallel-agent use has so far been observed mainly among senior-plus engineers.conf: high
extendsThe Orchestration Tax is You · p9 — This piece names the accessibility gap in parallel-agent orchestration (only senior+ engineers succeed at it); the other extraction supplies the underlying mechanism — the ceiling is set by how many agents one person can code-review properly.
explicitSpec-driven development (requirements.md/design.md/tasks.md as a durable, shared human-AI contract) appeals to developers because it survives context-window limits and session boundaries, giving agents a persistent source of truth to check implementation against — even though critics frame it as a return to waterfall.conf: high
extendsAgentic AI and Code Reviews · p7 — This piece names developers' desire for spec-driven artifacts as durable, session-surviving contracts; the other extraction specifies the mechanism — review relocates from implementation to the plan once the spec is hardened.
explicitReliability under production load, not impressive demos, is a top unresolved developer complaint: 2025 saw recurring issues (Claude's near-daily status-page incidents despite >99% headline uptime, Windsurf latency/crashing during long agent sequences, Antigravity 'model provider overload' errors) that break flow state.conf: high
explicitMany professional developers (as distinct from 'vibe coders') want human-in-the-loop controls — fine-grained permissions, approval gates before destructive actions (rm -rf, database writes, deployments), configurable per-task autonomy levels, and audit trails — making the friction-versus-safety trade-off an actively contested design dimension rather than one settled in favor of full autonomy.conf: high
supportsAWS Releases Loom, an Open-Source Reference Platform for Governing AI Agents at Enterprise Scale · p8 — Both describe human-in-the-loop review for sensitive/destructive agent actions as something implementable as a first-class platform capability (hooks/MCP elicitations), not merely a developer wish.
explicitBecause agents can now modify hundreds of files autonomously, rollback/checkpoint capability (e.g. Claude Code's automatic pre-change checkpoints and /rewind command) has become critical infrastructure — not just for recovering from mistakes but for letting developers confidently attempt ambitious, wide-scale tasks knowing they can always return to a known-good state that captures conversation context and tool outputs, not just git history.conf: high
supportsClaude Code: Best practices for agentic coding · p11 — Both point to Claude Code's rewind/checkpoint mechanism as the concrete implementation of the rollback capability developers want.
explicitDevelopers want to package reusable workflows into shareable, version-controlled 'skills' (e.g., a code-review or security-audit procedure defined once and invoked consistently across projects and teams) instead of re-engineering the same prompts repeatedly, encoding institutional knowledge that new team members can adopt immediately.conf: high
explicitThe developer role is shifting toward architecture, system design, prompt engineering, and quality judgment, with successful developers effectively delegating, reviewing, and guiding multiple concurrent AI agents — but agentic IDEs exist to serve developers, not replace them, and predictions of near-term engineering-team obsolescence have not materialized and will not.conf: high

Arguments

Agentic-IDE vendors should prioritize reliability, cost transparency, and controllable autonomy over flashy autonomous-demo capability, because developer-tool adoption is governed by sustained practitioner trust, not headline capability. strength: medium

Explicit premises:

2025's pricing volatility already generated developer blowback (p4).
Reliability complaints were loud and recurring across multiple vendors in 2025 (p8).
Professional developers actively want friction-inducing safety controls, not unconstrained autonomy (p9).
The piece's own closing claim: developer tools live or die by practitioner adoption, and developers are unforgiving of tools that waste time, break flow, or fail on promises.

Implicit premises:

That the 'fire and forget' background-agent autonomy developers want (p2) and the fine-grained, pre-action approval gates they also want (p9) are compatible demands on the same tool — the piece presents both as simply 'what developers want' without examining whether satisfying one constrains the other.

Inferences:

If developers want both overnight unattended agent runs and per-action approval gates before destructive operations, these pull in opposite directions on the autonomy spectrum; the practical resolution vendors are likely forced toward is coarser-grained, pre-authorized action classes (rather than literal per-action human gating) for background work — a design implication the piece doesn't draw out itself.

Questions addressed

✅ How has what developers want from AI coding tools changed since the author's 2023 and 2024 installments of this series?
The ask shifted from discrete-task assistance (autocomplete, then multi-file editing) to full workflow delegation with developer trust in agent output.
⭕ Are 'fire and forget' autonomy and fine-grained human-in-the-loop control compatible design goals for the same agentic IDE, or do they trade off against each other?

Gaps

illogicalDemand #1 (background agents: queue tasks overnight, review only the finished PR) and demand #8 (human-in-the-loop: approval gates before every destructive action, configurable autonomy per task) pull in opposite directions on the same autonomy spectrum. The piece lists both as simply 'what developers want' in 2025 without noting that satisfying one at scale constrains how fully the other can be honored — the more asynchronous and unattended an agent's run, the less feasible synchronous per-action approval becomes.
Read next: extract-aws-loom-ai-agent-governance, which treats human-in-the-loop as a platform capability (hooks/MCP elicitations) implemented around coarser pre-authorized action classes rather than per-action gating — the likely practical resolution this piece doesn't name.
uninformedThe disclaimer names RedMonk client relationships (AWS, Microsoft/GitHub, Red Hat, Tessl, Google) covering several of the vendors whose features illustrate the ten demands (AWS's Kiro pricing transparency and MCP push, GitHub's Spec Kit, Google's Antigravity). The piece doesn't flag which specific claims might be shaped by these relationships versus independently observed developer demand.
Read next: Compare vendor-neutral practitioner sources in this corpus (e.g. independent Claude Code/Cursor usage reports) for the same claims.
incompleteThe entire piece is framed around 'the developer' as a single individual user choosing and configuring their own agentic IDE. It never addresses how a team shares or negotiates persistent memory, a skills library, MCP server configuration, or spec-driven artifacts collectively — a genuinely open question for team-scale (not individual) agentic-IDE adoption.
Read next: extract-git-real-team-coding-agents and extract-claude-code-meetup-odense directly address team-scale (not individual) agent-harness coordination.