Robots-First Engineering

Software got built for people. The file system. The terminal. JSON. Git. Code review. All of it was shaped by what a human on a keyboard can handle.

What if you threw that out and started over for machines?

That is robots-first engineering. And it is the direction autonomous software development is already moving in.

Development Is Not Engineering Anymore

Here is the split that reframes the whole job:

Software development is now machine work. Writing code. Running tests. Committing. Agents already handle it. Call it roughly $10 an hour, no sleep, no breaks.

Software engineering is the human layer that keeps that machine reliable. Rails. Failure domains. Verification loops. Back-pressure. All the plumbing the agent runs inside.

Your job shifted under your feet. You are not hauling cargo onto the ship anymore. The shipping container showed up. Now you drive the locomotive and keep it on the track.

That mental flip is what separates engineers who thrive in the new world from engineers who flounder in it.

Screwdriver Before Jackhammer

Autonomous engineering has stages. Skip them and you fail.

The Screwdriver. Manual work. You write specs by hand. You manage context tightly. You steer search and linkage yourself. The goal is learning how the system stays on rails before you hand it the keys.

The Jackhammer. Full throttle. Ralph loops running unsupervised. Orchestrated fleets. Parallel agents. Overnight builds that ship features by morning.

Most engineers make the same mistake. They grab the jackhammer before touching the screwdriver.

Jump straight to full automation without the fundamentals and the output is garbage. The screwdriver is what teaches you what the jackhammer needs.

Go manual first. Figure out why things hold together. Then reach for the power tools.

Loom: A Stack Built for Agents

Loom points at the next step: a software environment that rebuilds itself around agents rather than humans.

The design rule is strict. For every piece of the stack, ask three questions:

1. Was this designed for humans?
2. If yes, can it go?
3. If it goes, what did we lose and how do we replace it?

A few assumptions that fail the test:

• Unix user space and TTY conventions. Agents do not sit at terminals. Does any of this still apply?
• Agile ritual and process. Sprints exist because humans plan in weeks. Agents do not.
• JSON as a data format. Every quote and bracket burns tokens. Is JSON the right wire format?
• Code review workflows. Can a verification loop replace a review queue?

Loom's pieces include:

• Code hosting, GitHub-like, but shaped for agents
• Source control via JJ, which plays better with machine workflows
• Codespace-style remote sandboxes
• Multi-LLM "alloying", running multiple providers together
• Actor and pub-sub message patterns
• Chaining in the style of Erlang/OTP

The core idea. Loops composed into chains. Loops on loops on loops. Each one tight and focused. The whole thing behaves as one reactive system.

Context Windows Are Just Arrays

A core principle for thinking robots-first:

A context window is an array. The less of that array you fill, the less it has to slide, and the better the output gets.

Pile in more context and you get:

• More sliding
• Earlier compaction
• Compaction that loses data
• Missing anchors
• Drift

This is why Ralph loops work at all. The loop is designed to run the array deterministically. Keep the array lean. Dodge compaction. Hold the pin.

The pin is your spec. The stable reference point the agent keeps pointing back at. Every iteration reads it again. Without the pin, agents start making things up.

Specs as Lookup Tables

Robots-first specs are not docs. They are lookup tables tuned for agent search.

A good spec looks like this:

## User Authentication
 
**Also known as**: login, sign-in, auth, session management, identity
 
**Related files**: src/auth/, src/middleware/session.ts
 
**Key patterns**: JWT tokens, refresh rotation, secure cookies
 
**What NOT to do**: Don't implement custom crypto, don't store passwords in plain text

The "also known as" field lifts search hit rates. When the agent greps for "login", it lands on the auth spec. More synonyms, more hits. More hits, less invention.

The spec becomes the reference frame for the whole feature. Agents look up what exists instead of guessing at what might.

Linkage Beats Fancy Formats

A lot of engineers over-build their plans. Nested JSON schemas. Task hierarchies. Elaborate formatting.

The robots-first take: tight linkage wins over fancy formats.

What actually works:

• Bullet points with concrete references
• Cite the exact spec section
• Point at the exact file
• Reference specific hunks (Claude reads files in hunks)

## Implementation Plan
 
- [ ] Add JWT validation middleware
 
  - Spec: auth-spec.md#token-validation
  - File: src/middleware/auth.ts (lines 45-60)
  - Pattern: Follow existing rate-limit middleware structure
 
- [ ] Create refresh token endpoint
  - Spec: auth-spec.md#refresh-flow
  - File: src/routes/auth/refresh.ts (new file)
  - Pattern: Match existing /auth/login endpoint structure

Now the agent searches with precision. It finds the right hunks. It copies the pattern already in the repo. It stops inventing.

The Robots-First Stack

Here the idea gets radical. Own the whole stack and you can tune it for machines:

Serialization. JSON is not token-efficient. Every quote, every brace, every comma costs tokens. A binary format, or a text format built for agents, could cut that cost sharply.

User Space. Why should an agent inherit Unix user space? TTY was built for humans at terminals. Agents do not need terminal emulation at all.

Garbage Collection. What does memory management even mean when your "process" is a stateless API call? The usual assumptions stop holding.

Message Passing. Erlang and OTP come back. Actors. Supervisor trees. Let-it-crash. The patterns map cleanly onto orchestrating agents.

If you own the stack, you get to:

• Tune tokenization
• Drop costs steeply
• Build faster reactive pipes
• Run cheaper than the next team

That is competitive advantage ground.

Weavers: Agents With No Human in the Loop

The destination of robots-first engineering has a name: Weavers.

A Weaver is an autonomous agent that:

• Ships code behind feature flags
• Deploys without a code review
• Watches product analytics
• Decides if a change fixed the errors
• Decides whether to push further
• Iterates on its own

No one is standing over it. Full autonomy.

Scary, yes. That is the right first reaction. Now sit with it for a second.

Every objection you can list is an engineering problem waiting to be built. What if it breaks prod? Engineer a rollback. What if it makes a bad call? Engineer a verification loop. What if it slides off the rails? Engineer back-pressure.

The new job of software engineering. Engineer the concerns away.

Write down your objections. Then build the systems that neutralize them. That is the work now.

Back-Pressure Engineering

Autonomous loops spin off failure modes. Your job turns into laying down the rails:

• Add constraints inside the spec
• Tighten the plan linkage
• Improve search guidance
• Raise the gates (tests, linting, formatting, security scans)

When outputs go bad, the fix is another loop:

• Refactor loop
• Convention loop
• Security loop
• i18n loop

Back-pressure keeps the generator on the track. The locomotive stays in line because you engineered the line.

The Scaling Ladder

Robots-first engineering scales by composition. Four rungs.

Level 1: Manual Fundamentals

• Generate specs through conversation
• Tighten constraints by hand
• Keep context as small as you can
• Stay at the keyboard

Level 2: Unattended Looping

• while true runs
• One objective per iteration
• Automated tests plus commit and push
• Checkpointed state

Level 3: Multi-Loop Orchestration

• Several loops running at once
• Reactive chains wired between them
• Actor and pub-sub patterns

Level 4: Autonomous Product Systems

• Weavers shipping features
• Analytics driving decisions
• No review queue
• End-to-end product autonomy

Each rung rests on the one below. Jumping to Level 4 without Levels 1 through 3 does not work.

The Mindset Shift

Robots-first engineering needs a different head:

Old mindset. "How do I write this code?" New mindset. "How do I design a system that writes this code reliably?"

Old mindset. "How do I review this PR?" New mindset. "How do I build verification that makes review pointless?"

Old mindset. "How do I debug this issue?" New mindset. "How do I engineer feedback loops that stop this class of bug?"

You are not writing code anymore. You are designing autonomous systems. You are a locomotive engineer, not a dockhand.

Getting Started Today

You do not need Loom to start thinking robots-first. Start with questions:

1. What human assumptions am I baking in? Audit your workflows. Which steps only exist because a human was the one doing them?

2. What could become a lookup table? Your specs. Your patterns. Your conventions. Can you shape them so an agent can search them?

3. Where is linkage weak? Most plans point at things loosely. Can you hardcode file paths, line ranges, and hunks instead?

4. Where is the back-pressure? When the agent goes sideways, what catches it? Build those brakes before you need them.

5. What would full autonomy need? Pretend you stepped out of the loop. What falls apart? Those failures are your next engineering priorities.

Where This Goes

This is 2026. Buckle in.

The gap between teams that can run reliable autonomous loops and teams that cannot is widening fast. The economics are stark. Automated development is roughly $10 an hour. Human developers are $100 and up.

Teams that build robots-first ship at a different rate entirely. They run cheaper. They iterate faster. Their improvements compound while they sleep.

Engineers stuck on human-first workflows are going to fall behind. Not because their skills are bad. Because their optimization target is wrong.

Software engineering just changed. It has changed before. It will change again.

The engineers who do well are the ones who see each change as another chance to design from first principles. That has always been true. It is just harder to ignore now.

Start with the screwdriver. Get the fundamentals right. Then reach for the jackhammer.

The locomotive is waiting.

Related Reading

• Ralph Wiggum Technique. The foundation for autonomous loops
• Thread-Based Engineering. A framework for scaling agent work
• Autonomous Agent Loops. Ralph plus threads together
• Feedback Loops. Verification patterns that keep loops honest
• Context Engineering. Managing the array