Ships in the night

Published January 1, 2026

The text cursor is a 1970s interaction primitive that assumed the bottleneck was typing speed, so we optimized for characters per minute: syntax highlighting, autocomplete, vim motions. Today, agents generate code faster than humans can read it. The constraint is intent specification and output review. The question becomes how precisely you can specify what you want and how quickly you can verify it.

Trace the evolution of engineering roles from 2020 to 2030. Watch as "code production" shifts from human to AI, and "intent specification" emerges as the new core competency.

From files to diffs

Recent IDEs still orbit the file, even as they bolt on agent panels and codegen. The trend is a hybrid editor plus agent and it feels transitional. When an agent can generate a file faster than you can open it, the file stops being the natural unit. The unit of work shifts to the diff, describing what changed and why rather than presenting the full code. A pull request becomes a claim about intent, packaged with evidence. Review shifts from syntax and tests to whether the intent was correct.

Specification as skill

"Build me a login page" is a wish, not a specification. A specification includes authentication method, session handling, error states, rate limiting, accessibility, mobile behavior, and integration points. The gap between wish and specification is where most AI coding failures happen. The model does exactly what you asked. You asked for the wrong thing.

The wish:

Build me a login page.

The specification:

Build a login page:

Auth: email/password via /api/auth, JWT in httpOnly cookie, 24h expiry
Session: redirect to /dashboard on success, preserve ?redirect= param
Errors: inline messages, rate limit countdown, retry on network failure
Security: 5 attempts per 15 min, CSRF token, no credentials in localStorage
Accessibility: labels, screen reader announcements, focus management
Mobile: 44px touch targets, keyboard-aware layout
Integration: use Button/Input from /components/ui, follow theme vars

The modern software development skill is specifying precisely. Every ambiguity becomes a branch point where the agent can go wrong. This is the same skill that makes staff and senior engineers effective with mid-level and junior engineers, except the "junior" now runs at 100 tokens per second and the bottleneck is context windows, review bandwidth, and rate limits.

The optimal point is rarely maximum specification. Contracts, types plus tests, take a bit more upfront time than a spec and eliminate most revision cycles. Total human time drops once you invest enough upfront to reach a high success rate, then you can rely on the agent for edge cases.

Swarm and IDE shift

Most agent stacks still run through hub-and-spoke APIs. If multiple agents are local, routing every message through a distant service adds latency and cost, and a local mesh is often enough for coordination. The human role shifts to setting the goal, constraints, and acceptance criteria, then reviewing outcomes. A swarm can split the labor across scanning, implementation, tests, and security. They stay aligned through shared context and ensemble consensus. That coordination needs shared intent formats that are explicit and checkable, not just prose. Projects like Reploid explore recursive verification loops for agent workflows.

The text editor does not disappear. You still read code, make surgical edits, and debug at the line level. It becomes a view into the system, not the primary interaction surface. The primary surface is a bundle of workflows. Intent specification: a structured form where you define what you want, not how to get it. Execution monitoring: a live view of swarm activity, disagreements, and progress. Review queue: proposed changes ranked by confidence. Knowledge graph: a live map of the codebase as the swarm understands it, updated continuously as the codebase evolves.

The transition

We are not there yet. Most tools are still hybrids, a text editor with AI layered on top. The interaction model is familiar, not redesigned for agents. Agentic CLIs are exploring that space, but they still struggle with visibility and trust. It is easy to lose track of what is happening or to watch a tool act without permission.

The transition will be uneven. Muscle memory around typing, file navigation, and syntax highlighting matters less. The new core skills are specification precision, intent review, and constraint design. Each AI step makes the typing and debugging loop less central and the specifying and reviewing loop more central. The decision is whether we build specification skills or optimize keystrokes that will be automated. We are shaping systems that build tools with us, so our role is to steer what gets built and why.