Software Factory Archive

Jay didn't trust things he couldn't step through.

It was an SRE habit, baked in from years of incident response, from the accumulated muscle memory of a career spent debugging systems that had done something unexpected at three in the morning. You didn't just run the fix. You ran the fix one step at a time, checking the output after each step, making sure the system was where you expected it to be before you told it to advance.

agate auto was the fire-and-forget command. It ran the whole loop—interview, design, sprint, implement, assess—stopping only when the goal was met or human input was needed. It was the command for when you trusted the process.

agate next was for Jay.

Each invocation advanced exactly one step. Run it once: the interview phase begins. Run it again: the design phase begins. Run it again: sprint planning. Again: implementation of the first task. Again: implementation of the second task. Each step discrete, observable, interruptible.

He liked it the way he liked git add -p—patch by patch, hunk by hunk, never committing anything he hadn't personally inspected. It was slower than agate auto. That was the point. Speed wasn't what Jay was optimizing for when he used next. He was optimizing for understanding.

On a Tuesday afternoon, when the office was quiet and Navan was in a meeting, Jay opened a terminal and wrote a shell loop:

while agate next; do echo "--- step complete ---"; read -p "continue? " reply; done

It was primitive. It was beautiful. Each step would run, print a separator, and then wait for him to press Enter before continuing. A human-gated loop around a machine-driven process. The SRE's version of trust: verify, then advance.

He ran it against a new GOAL.md—a utility that monitored disk usage and sent alerts when partitions exceeded configurable thresholds. The kind of tool he would have written by hand in a previous life, before the factory.

Step one: interview. He read the generated questions. They were good. He answered them.

Step two: design. He read the overview and decisions documents. Solid architecture.

Step three: sprint planning. Seven tasks, clean dependency graph.

Steps four through ten: implementation. He watched each file materialize, read each one, checked each against the design. The code matched. The tests were thorough. The edge cases were covered.

Step eleven: assessment. Tests passed. Goal met. Exit code 0.

Eleven presses of the Enter key. Eleven moments where a human said: I see what you did, and you may continue.

Jay closed the terminal and leaned back. He didn't need agate next for every project. But he was glad it existed. It was a concession to the kind of engineer who needed to watch the gears turn. An acknowledgment that trust is built one step at a time.