Boris Cherny on How Development Tools Are Shifting from IDEs to Agent Consoles

After watching Boris Cherny’s interview at Sequoia AI Ascent 2026, the author revisits earlier analyses of Claude Code, Harness, Context Worksets and Skills, noting that the discussion cannot be reduced to “AI makes coding faster.”

Product evolution beyond traditional SaaS

Claude Code’s growth did not follow the classic SaaS path of incremental product‑market fit validation. Instead, the team bet on a future jump in model capability, released an early product shape that seemed unusable, and when the model’s abilities crossed a threshold the previously premature interactions suddenly became viable.

From IDE cursor to Agent workflow console

The central claim is that the focus of development tools is moving from the cursor inside an IDE to a console that manages Agent work‑flows. The original question—“Can AI help engineers write code faster?”—has evolved into a set of deeper questions:

How do humans articulate clear goals?

How do Agents execute those goals continuously?

How does the system record the process, approve risky actions, and verify or roll back results?

This shift is not limited to Claude Code; it reflects a broader migration of software‑engineering control points.

Software 3.0 perspective

Karpathy’s talk on “Software 3.0” at the same conference highlighted a similar insight: after rapid model breakthroughs at the execution layer, the architectural layer becomes the harder problem. The interview adds concrete engineering practice to that view.

TL;DR – key takeaways

Boris’s statement “coding is solved” must be unpacked; code generation is strong in mainstream scenarios, but governance, verification and responsibility remain.

Claude Code now embeds Agents into repositories, terminals, Git, CI and PR pipelines.

The concept of a “Loop” turns a single model response into a continuous observation‑execution‑repair‑report cycle.

All previously discussed topics—Agent Harness, Context Worksets, Subagents, Skills, Process Assets—lie on the same line.

Future development tools will likely be Agent‑workflow consoles rather than just IDEs or terminals.

Engineers’ value shifts from writing code to defining goals, boundaries, verification, risk and system ownership.

Code generation vs. engineering complexity

Even though code generation becomes cheap, software engineering does not become simpler. The more an Agent can do, the earlier governance problems surface. A weak autocomplete may produce a few bad lines; an Agent that can read repositories, modify files, run commands, interact with Slack, query databases, fix CI and open PRs behaves like a new participant in the engineering process.

New development workflow

Traditional path:

Human reads requirements → opens file → writes code → runs tests → fixes bugs → submits PR

Agent‑augmented path:

Human defines goal → Agent reads context → Agent plans → Agent modifies code → Agent runs tests → Agent iterates on failures → Human reviews diff, commands, risks and final result → Human decides merge

The crucial change is not who writes code but who controls the work‑flow: goals, constraints, permissions, budgets, verification and review.

Agent console as the new IDE

When Agents become long‑running processes, the IDE must surface more than model output. It needs to show what the Agent is doing, which step it is on, failure counts, changed files, invoked tools, token consumption, dangerous resource accesses, and actions awaiting human confirmation. The IDE therefore evolves into an observation, scheduling and review console for Agent work‑flows.

Re‑architecting SaaS entry points

AI does not eliminate SaaS products; it moves the human front‑end out of individual applications and into an Agent‑driven backend. Users may issue a single command—e.g., “fetch the last three months of client communications, list risk points, update CRM, generate a follow‑up plan, sync to Slack, and add a summary to the monthly report”—while the underlying SaaS tools (Salesforce, Jira, Google Docs, etc.) continue to operate behind the scenes.

Organizational implications

Anthropic’s internal advantage lies as much in its processes as in its models. External teams cannot simply copy Anthropic’s internal state; they must redesign workflows, permissions, audit trails and responsibility structures to accommodate Agents. Questions arise about which tasks can be delegated to persistent Agents, who reviews Agent output, how budgets are accounted for, and who can stop a misbehaving Loop.

Team topology and expertise

Agents blur the line between developers and other roles. In the Claude Code team, engineers, product managers, designers, data scientists, finance and user researchers all write code. This does not mean everyone becomes a traditional engineer; rather, code becomes a shared expressive medium, and deep domain expertise combined with Agent tooling becomes the new competitive advantage.

Conclusion – from code production to Agent system design

The core message is that software engineering is transitioning from merely producing code to designing, governing and iterating on Agent‑centric work systems. Engineers remain essential, now focusing on specifying goals, bounding actions, validating outcomes, handling failures and embedding domain knowledge into Agent workflows.

As Karpathy said, “You can outsource thinking, but you cannot outsource understanding.” This insight applies directly to the evolving landscape described by Boris Cherny.