Ships in the night

Published January 1, 2026

Software is getting another compiler layer. C++ let engineers work at the source level without reading every assembly instruction. Agents push the boundary up again: human intent compiles into source code, and the job shifts from reading every generated line to checking interfaces, diffs, tests, constraints, and failure evidence.

Engineering work shifts from line-by-line authorship toward intent, diffs, and constraints.

From files to diffs

Recent IDEs still orbit the file, even as they bolt on agent panels and codegen. That feels transitional. When code is generated from intent, the file stops being the natural review unit. The unit of work shifts to the diff: what changed, why it changed, and what evidence says the change is valid.

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 many AI coding failures happen: the request leaves out the constraints that determine whether the output is usable.

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, viewport-safe 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. The familiar senior-engineer skill still applies: define the target, constraints, and acceptance checks before delegating the implementation.

The goal is rarely maximum specification. Contracts, types, and tests encode the parts that matter and reduce revision cycles.

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 remains a line-level view for reading, surgical edits, and debugging. The primary surface becomes 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

Most tools remain hybrids: a text editor with AI layered on top, leaving visibility and trust problems unresolved. Agentic CLIs are exploring that space, but source code is becoming an audit target instead of the main surface.

The new core skills are specification precision, intent review, and constraint design.