Ships in the night

Published January 1, 2026

Software keeps adding layers where humans stop writing the lower form directly. C let engineers stop hand-writing most assembly. Agents are doing the same thing to source code: intent becomes an artifact, the artifact becomes a diff, and the diff becomes something to check.

The job does not disappear. It moves. Source code becomes less like the primary work surface and more like an audit target: something you read when the interface, tests, types, traces, or behavior say the generated system is wrong.

The center of work moves from typing lines to shaping intent, reading diffs, and enforcing constraints.

From files to diffs

Most IDEs still treat the file as the main object. Agent tools bolt panels onto that world, but the interesting object is becoming the diff. What changed? Why did it change? What evidence says the change is valid?

A file is where the result lands. A diff is where the claim lives. It says this system should move from state A to state B, for this reason, under these constraints. That is a better review unit for generated code because it keeps the human focused on intent, boundary behavior, and evidence instead of every line produced along the way.

Specification as skill

"Build me a login page" is a wish, not a specification. The missing details are where the agent makes choices for you: authentication method, session handling, error states, rate limits, accessibility, mobile behavior, integration points. Sometimes those choices are fine. Often they are just unreviewed product decisions.

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 skill is not writing more words. It is closing the branches that would let the agent build the wrong thing. 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: define what you want, not every step for getting it. Execution monitoring: watch agent activity, disagreements, and progress. Review queue: inspect proposed changes ranked by confidence. Knowledge graph: see the codebase as the swarm understands it.

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. Just as C moved most engineers above assembly, the agent layer moves engineers above routine source production. The work shifts to defining what counts as valid output.