Ships in the night

Originally conceived January 1, 2026

From Writing Code to Reviewing Intent

The text cursor is a 1970s interaction primitive. It 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 new constraint is intent specification and output review. An IDE optimized for typing is optimized for the wrong constraint. The question is not how fast you can write code. It is 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.

The diff as artifact

Recent IDEs still orbit the file, even as they bolt on agent panels and codegen. The trend is a hybrid editor plus agent. That feels like a transitional design, not the end state. 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. Not "here's the code," but "here's what changed and why." A pull request becomes a claim about intent, packaged with evidence. The default view is a diff reader, source editing becomes an advanced feature, and manual edits become the exception because they are harder to audit. Review shifts from syntax and tests to whether the intent was correct.

The specification problem

"Build me a login page" is not a specification. It is a wish. 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 not coding faster. It 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 rate limits shift from coffee, breaks, sleep, vacation to context windows, requests per second, and weekly throughput, depending on the plan you pay for.

The optimal point is not maximum specification. "Contract" takes slightly more upfront time than "Specification" but eliminates most revision cycles. Total human time drops when you invest enough to reach a high success rate, then let the agent handle edge cases.

The swarm architecture

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. A local mesh is often enough for coordination. The human role shifts to setting the goal, constraints, and acceptance criteria, then reviewing outcomes. The system proposes a decomposition. We catch when it misses a constraint or the goal was underspecified.

A single agent can ship, but it is still serial work. A swarm can split the labor: one scans the codebase, one implements, one writes tests, one reviews for security issues. 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 IDE of 2027

The text editor doesn't disappear. You'll still read code, make surgical edits, and debug at the line level. But it becomes a view into the system, not the primary interaction surface. The primary surface is:

Intent specification: A structured form where you define what you want, not how to get it. Types, constraints, acceptance criteria. The more precise the form, the less revision later.

Execution monitoring: A live view of swarm activity, disagreements, and progress. You can intervene, but you don't have to.

Review queue: A stream of proposed changes ranked by confidence. High-confidence changes auto-merge. Low-confidence changes surface for human judgment.

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 not just building a tool. We are shaping systems that build tools with us. Our role is to steer what gets built and why.