Don’t Take It From Me. Take It From Them.
Spec-driven development, agent loops, and the evidence behind what I saw at AutoCon 6.
- MONDAY“What the hell
is SDD?” - TUESDAY · 1 P.M.A game
they built. - TUESDAY · 2 P.M.Taking it back
to their teams.
On Monday at AutoCon 6, some of the people I spoke with were asking, “What the hell is SDD?”
On Tuesday, those same people came to a four-hour workshop. Two hours of lecture. Two hours of building. We used the process and tools in this article to make networking video games. The workshop ended at 1 p.m.[1] [2]
By 2 p.m., some of those engineers already had a game and were seeking management approval to bring this way of working into their organizations. They were telling their teams what they had discovered. An hour after we finished, the lesson was already traveling beyond the room.
Ten million percent in.
That is the change I want you to understand. People who had barely encountered the term the day before could now point to something they had made. The next conversation was about what else they could build, and who needed to see it.
It felt like the Wizard teaching Billy Batson the word SHAZAM. As though I had leaned over and whispered the magic words in their ear, and suddenly they could do something they had not thought possible.
The words were available to everyone: write down what you want, make the constraints explicit, give the agent a task, and make it demonstrate that the result works. Repeat. Their networking knowledge and imagination gave the process somewhere worth going.
I had hoped for six games. About 75 people were in the room, some working together, some alone. My original recap recorded the first game live 41 minutes after building began. Seif Allaoua later reported 68 minutes to build PacketJedi and three more to publish it. The arcade kept growing afterward, with revisions and new submissions through the week. Those are different milestones; the collection includes work completed after the workshop.[2]
Go read “I hoped for six games. They built an arcade.” Then play a few. John Armstrong could not attend, but used the materials to build Threat Level: Goose on his own. That matters to me as a teacher: the lesson could travel without me standing beside the student.[2]
The work that brought me into that room
A free Ubuntu CD drew me into open source in 2005. Since then, my work has taken me through network automation, Automate Your Network and the pyATS book, public code, and years of teaching. The thread I keep coming back to is helping engineers turn what they know into something they can run, inspect, and share.
My live session with Andy Lapteff, “Stop Vibe Coding: Start Spec-Driven Development,” helped turn that instinct into this workshop. Andy was driving. I wanted him, and later the room at AC6, to experience the process at the keyboard.[2]
Today that work includes NetClaw, my open-source network engineering agent. Connecting an agent to tools makes a network question actionable. It also makes the quality of the instructions, the evidence, and the boundaries much more consequential.[3]
At AC6 I brought both a workshop and a talk: “Loop Engineering, Spec Driven Development, and the Future of VibeOps” on Tuesday, followed by “Agentic Networking is here” on Thursday. They address the same question from different directions: what must an engineer put around an agent so it can do useful work we can inspect?[1]
The games gave people a manageable place to discover their own capability. NetClaw is why I keep asking how that capability should meet real infrastructure. A convincing demonstration starts a conversation; reliable operations require more evidence.
You do not owe me belief
Some people are already all in. Others are right there. They want to believe what they are seeing, but understandably want to hear it from somebody more credible than the enthusiastic person who just taught the workshop.
There is no blow to my ego in that. I agree. Go seek outside confirmation of my hypothesis. Read the criticism, too.
I am not asking for faith in me or in this process. I am not asking anyone to fill a gap in evidence with belief. Bring curiosity. Ask Socratic questions: What exactly am I claiming? What would count as success? What would show I am wrong? Then use the scientific method: run an experiment, inspect the evidence, and revise the claim.
My hypothesis is that explicit specifications, small tasks, and bounded loops with meaningful verification can help network engineers build useful systems and make changes with less avoidable rework. The workshop gives me a reason to investigate that hypothesis. It does not settle its effect on production defects, security, or release speed.
Don’t take it from me. Read the engineering accounts from Microsoft, GitHub, Amazon, Google, Anthropic, OpenAI, and Meta, and the experience Jake Nations shared from Netflix. They describe related practices: preserving intent, planning work, giving agents durable context, and checking results. The overlap is useful. Company names are not a substitute for measurements, and these accounts do not all evaluate the same workflow.
Network engineering has spent years adapting practices from software engineering: version control, tests, review, and delivery pipelines. At AC6, I saw people connect those familiar disciplines to a new way of building. I want us to investigate that connection while it is happening.
Let’s compress the timeline by learning and measuring, with the same engineering standards we expect from any other change.
Part One follows the history of specifications and feedback. Part Two brings together engineering accounts and measured results, including findings that challenge the argument. Part Three connects specs to agent loops and ends with an experiment you can run in your own environment.
Part One: How We Got Here
Every Era Was an Argument About the Same Thing
Every methodology in this section answers one question: how do you turn intent into a working system without losing the intent along the way? The answers change because the costs change. Watch what is expensive in each era and the method explains itself.
- WaterfallRequirements before implementation
- LeanSmall batches; stop for defects
- Agile & TDDShort cycles; executable checks
- NetDevOpsVersion, test, review
- Specs & loopsDurable intent; repeated verification
The recurring question: how do we keep intent intact while learning from the result?
Waterfall: the spec was fine, the feedback was missing
In 1970 Winston Royce described a sequential model for large software projects: requirements, design, implementation, verification, maintenance. The irony is that Royce presented the strict one-pass version as risky. The industry adopted it anyway and later named it Waterfall.
Waterfall wrote everything down. Requirements were signed off before design, design before code. Then feedback arrived months or years later, when the cost of being wrong was at its peak.
Keep that distinction in mind for the rest of this article. Waterfall did not fail because it wrote things down. It failed because writing was slow, changing what was written was slower, and nobody learned the spec was wrong until the end. If that sounds like a design document, a change advisory board, and a quarterly maintenance window, it should.
Lean: what Toyota worked out on a factory floor
The Toyota Production System, built largely under Taiichi Ohno in the decades after the Second World War, attacked the same problem from the other side. Build in small batches. Pull work only when it is needed. Write down standard work so it can be improved. And when a defect appears, stop the line. Any worker could pull the andon cord and halt production, because a defect passed downstream costs more at every station it reaches.
The West labelled this Lean in the late 1980s, and Mary and Tom Poppendieck carried it into software in 2003. Three ideas survive intact into everything that follows: small batches, written standard work, and stopping the line the moment something fails.
Hold on to the andon cord. It comes back in Part Three under a new name.
Agile, TDD & Clean Code: shrink the loop
In 2001, seventeen practitioners met in Snowbird, Utah and signed the Agile Manifesto. Its core move was to shorten the feedback loop from months to weeks and to value working software over exhaustive documentation.
Extreme Programming and Kent Beck’s test-driven development (TDD) shortened it again. Red, green, refactor. Write the failing test first, write the minimum code to pass it, clean up, repeat. A test written first is an executable specification. It states what done means before any implementation exists, and it gives an unambiguous signal when you get there.
Robert C. Martin’s Clean Code (2008) added the reader. Code is read far more often than it is written, so write it for the next person.
Agile also produced an overcorrection. Plenty of teams heard “working software over comprehensive documentation” as “no documentation.” Intent moved into standups, chat threads, and people’s heads. That worked while every team member was a human who carried context from one day to the next.
An agent joining a new session needs that intent made available explicitly. Durable files can carry context that a conversation alone may not preserve.
DevOps & NetDevOps: the pattern that should bother us
DevOps arrived around 2009 and tore down the wall between the people who write software and the people who run it. Infrastructure became code. CFEngine dates to 1993, Puppet to 2005, Chef to 2009, Salt to 2011, Ansible to 2012. Version control, peer review, and CI/CD pipelines became the default way to change a server.
For years those tools managed servers while network engineers were still pasting into terminals. Networking joined in the mid-2010s. Ansible’s agentless model fit devices that would never run an agent, and network modules followed. Python libraries such as Netmiko, NAPALM, and later Nornir gave engineers programmatic access. Cisco released pyATS publicly in late 2017 and brought real test discipline with it: learn the state, snapshot it, change something, diff, assert. Sources of truth, pre-checks, and post-checks became the vocabulary of a serious team. We called it NetDevOps.
Now look at the gaps.
| Practice | Arrived in software | Arrived in networking | Rough lag |
|---|---|---|---|
| Configuration management as code | Puppet 2005, Chef 2009 | Network modules for Ansible and Salt, mid-2010s | 5 to 10 years |
| DevOps | 2009 | NetDevOps, around 2015 to 2016 | About 6 years |
| Test-first discipline | TDD, early 2000s | pyATS public in 2017, Batfish, CI for network changes | About 15 years |
| Spec-Driven Development and loops | Mid-2025 to mid-2026 | AutoCon 6 workshop, November 2026 | About 16 months, so far |
These are rough milestones, not measurements of industry-wide adoption. Network teams adopted these practices at different times. AC6 is one example of engineers trying specs and loops together, not the date networking discovered them.
AIOps & MLOps: machine learning, not language
The next wave, from the mid-2010s, was machine learning in the statistical sense. Not chatbots. Anomaly detection on telemetry, event correlation, alert noise reduction, capacity forecasting, failure prediction. Gartner coined AIOps around 2016. MLOps grew up alongside it as DevOps for models: versioned data, training pipelines, drift monitoring.
These systems helped operators recognize patterns and could feed automated remediation, but they usually depended on predefined models and workflows. Language models added a different interface: interpreting a request and selecting among connected tools.
AgenticOps and “Vibe Ops”: the model can act now
Large language models with tool calling removed that ceiling. With the Model Context Protocol (MCP), introduced in late 2024, an agent can read the ticket, query the source of truth, run the show commands, draft the config, and push it.
In February 2025 Andrej Karpathy named the first way most people used this power: vibe coding, building software while forgetting the code exists.[4] Apply the same instinct to operations and you get what many of us call VibeOps: describe the outcome in plain language and let the agent work.
I like VibeOps. I have watched it invite people into building who had found the old entry points intimidating. But an improvised prompt is a weak change specification. Microsoft’s practical introduction describes the familiar cycle of prompting, retrying, and guessing.[5] On a lab game, a mistake may cost an afternoon. On a production network, the consequences can be much larger.
Vibes are a fine way to start. They are a terrible way to run a change window.
So what turns VibeOps into something you would let near production? The same two things the software world has added since mid-2025. Specs. And loops.
Part Two: Take It From Them
What Spec-Driven Development Actually Is
Microsoft’s definition is the cleanest I have found. Teams define guardrails, requirements, constraints, acceptance criteria, and edge cases up front, then use AI to generate code, tests, and supporting artifacts from that shared context.[6] IBM’s is close: a detailed specification is authored and agreed before development begins.[7]
“So it’s Waterfall.” No, and the people who built the tooling are explicit about it. Den Delimarsky of Microsoft, writing a week after GitHub released Spec Kit, says SDD is not exhaustive requirements documents, not waterfall planning, and not more bureaucracy. He calls it “version control for your thinking.”[8]
The useful difference is the feedback cycle. A short specification can change as we learn, and an agent can help implement the next version quickly. Implementation, review, and testing still cost time and money. The aim is to make human judgment explicit early enough that the next iteration can use it.
GitHub Spec Kit makes the workflow concrete. A constitution holds the non-negotiable principles. Specification captures the what and the why. Planning captures the how. Tasks break the plan into small, ordered units of work. Then the agent implements.[8] [9] The artifacts remain in the repository for review and revision.
Rigor comes in levels. The literature describes spec-first, spec-anchored, and spec-as-source, from lightest to strictest,[10] [11] and IBM’s guidance is that the right level depends on your codebase, team, and problem.[7]
- ConstitutionPrinciples and boundaries
- SpecificationBehavior and acceptance criteria
- PlanApproach and test strategy
- TasksSmall, ordered work units
- ImplementationCode and evidence
Human review at the relevant checkpoints. Revise the artifacts when the intent changes.
What engineering teams are doing
These accounts show that serious teams are trying related approaches. Read them for the mechanisms and the limits. Measured outcomes come next.
Microsoft & GitHub
GitHub introduced the open-source Spec Kit on September 2, 2025.[9] Microsoft describes a spec-first approach in its own engineering work, with specifications treated as central artifacts in the software lifecycle.[12] Adoption establishes that the approach is being used; it does not, by itself, establish a defect-reduction percentage.
The October 2026 follow-up matters most to anyone who runs infrastructure for a large organization. It describes presets, extensions, bundles, workflows, and governed catalogs, plus a layered constitution: an organization baseline that applies everywhere, a domain and technology overlay, and narrow team customization on top.[13] If you have ever maintained a corporate standard, a regional exception, and a site-specific override, you already understand the model.
Amazon
AWS launched Kiro in July 2025 as an IDE built around specs.[14] A Kiro spec is three files: requirements.md written in EARS notation, design.md, and tasks.md.[15] At re:Invent 2025, the Kiro team presented SDD as requirements, design, and tasks, and showed how its own engineering team uses Kiro to build and ship features.[16]
Google shipped Conductor for Gemini CLI in December 2025. Its pitch: stop depending on chat logs that disappear, and keep formal specs and plans in persistent Markdown files next to the code, reviewed before any code is written.[17] By July 2026 Google was calling this spec-driven development outright and extending Conductor to Antigravity, with spec.md and plan.md still at the center.[18]
Anthropic
Anthropic’s engineering team published its harness for long-running agents in November 2025. An initializer agent expands the user’s prompt into a comprehensive file of feature requirements. Every later session starts with a fresh context window, reads a progress file and the git log, picks the highest-priority unfinished feature, works on that one feature, and leaves clear artifacts for the next session.[19]
The March 2026 follow-up is blunter. Decompose a product spec into a task list. Implement one feature at a time. Hand off with structured artifacts. In its testing at the time, the team found that compaction alone was not enough and that full context resets, paired with a structured handoff, were essential on long tasks.[20]
OpenAI
In February 2026 an OpenAI team described building an internal product of roughly a million lines over five months with no manually written code. The engineers’ job became designing environments, specifying intent, and building feedback loops. Their repository holds a product-specs directory and execution plans with progress and decision logs, all checked in, with a short AGENTS.md acting as a map. Their summary: “Humans steer. Agents execute.” They also name the pattern they use to drive work to completion: a Ralph Wiggum loop.[21]
Meta
Meta does not publish under the SDD banner, but it arrived at the same lesson. In April 2026 its engineers described a swarm of more than 50 agents that produced 59 concise context files encoding tribal knowledge that had lived only in engineers’ heads, taking AI-readable coverage from about 5% to 100% of the modules across more than 4,100 files. Their advice: write a compass, not an encyclopedia.[22]
Netflix
Jake Nations, then an engineering lead at Netflix, shared a talk about shipping AI-generated code he did not understand. He described a three-phase discipline of research, planning, and implementation that records system understanding before implementation.[23] This is a practitioner’s account, not evidence of a Netflix-wide SDD mandate.
And well beyond big tech
GEICO’s engineering blog is running a series on specification-first practice.[24] Thoughtworks added SDD to its Technology Radar.[4] There is an Apress book,[25] an arXiv practitioner’s guide,[10] and a Wikipedia entry.[26]
| Who | What they published | When | What lives on disk |
|---|---|---|---|
| GitHub and Microsoft | Spec Kit, enterprise extensibility, layered constitutions | Sept 2025 to Oct 2026 | constitution.md, spec.md, plan.md, tasks.md |
| Amazon | Kiro spec-driven IDE | July 2025 | requirements.md, design.md, tasks.md |
| Conductor for Gemini CLI and Antigravity | Dec 2025, July 2026 | spec.md, plan.md | |
| Anthropic | Harnesses for long-running agents | Nov 2025, Mar 2026 | Feature list, progress file, git history |
| OpenAI | Harness engineering with Codex | Feb 2026 | Product specs, execution plans, decision logs |
| Meta | Codified tribal knowledge for agents | Apr 2026 | 59 concise context files |
| Netflix (Jake Nations) | Research, plan, implement | Dec 2025 | Research and plan documents |
Across these accounts, a recurring design choice is to give agents explicit intent and durable working context. The details differ, and so do the results each account can establish.
That is enough to justify a closer look. Now ask what has actually been measured.
What the numbers actually support
The evidence comes in different forms: controlled experiments, industrial case studies, vendor observations, and our own workshop experience. Some of the researchers work for the companies selling the tools. Their methods and limitations matter as much as their names. The studies below support parts of the approach; they do not establish a single universal improvement from “SDD plus Ralph.”
More completed work
A study combining three randomized field experiments at Microsoft, Accenture, and an anonymous Fortune 100 company covered 4,867 developers. It estimated a 26.08% increase in completed tasks from using an AI coding assistant, with a standard error of 10.3 percentage points. The individual experiments were noisy.[27]
That is evidence that AI assistance can improve task throughput in real organizations. It does not mean every developer became 26% faster, that releases accelerated by 26%, or that a particular specification workflow caused the gain.
Code that meets a testable requirement
GitHub’s randomized code-quality study analyzed 202 valid submissions from experienced Python developers building API endpoints. Developers with Copilot access had a 53.2% greater likelihood of passing all 10 unit tests. Reviewers were blind to whether AI had been used, and GitHub reported higher quality ratings across several dimensions.[28]
Read that carefully: a greater likelihood of passing all the tests is different from “53.2% fewer bugs.” The same report’s 13.6% figure concerns how many lines could be written before a readability error, not a reduction in production defects. It is a vendor-run experiment on a bounded task. Still, testing functionality against a defined requirement is much more informative than asking whether the developer felt productive.
Fewer defects from an older part of the method
We have evidence for the verification discipline that predates coding agents. A 2008 study of four industrial teams, three at Microsoft and one at IBM, reported 40–90% lower pre-release defect density with test-driven development compared with similar projects without it. The teams also estimated 15–35% more initial development time.[29]
Those were case studies, not randomized trials, and they studied TDD rather than AI or SDD. I include them because the testing discipline has its own evidence. If we borrow the benefit, we must also acknowledge the effort and avoid presenting an old TDD result as a new AI result.
Security findings fixed sooner
GitHub’s Copilot Autofix public-beta data from May–July 2024 reported a median 28 minutes to commit a fix for a new CodeQL pull-request alert, compared with 1.5 hours for manual fixes. For SQL injection, the reported medians were 18 minutes versus 3.7 hours.[30]
These are vendor-observed remediation times, not a randomized security trial or evidence that generated code has fewer vulnerabilities. They show a useful combination: a scanner identifies a concrete problem, an AI tool proposes a change, and a developer can review it. That is much closer to the feedback loop I want than accepting “looks secure” as a test result.
Faster delivery still needs a stable system
DORA’s 2025 research associated AI adoption with improved delivery throughput while continuing to find problems with delivery stability. Its year-end account describes AI as amplifying the system around it.[31] That finding belongs beside the positive numbers. Generating changes faster is only useful if review, testing, and recovery can keep up.
Taken together, these results give us reasons to experiment with AI assistance and strong verification. They leave an important question open: how much does our exact combination of specifications, tools, loops, and review improve our own work?
What the skeptics get right
I said to seek evidence. That includes results I would rather had come out differently.
METR’s early-2025 randomized trial involved 16 experienced open-source developers and 246 tasks in repositories they knew well. With AI available, they took 19% longer. Afterward, they still believed AI had made them faster.[32] Enthusiasm and measured performance can disagree. I need to remember that when I describe the energy in the AC6 room.
Keep the date attached. In February 2026, METR reported newer results pointing toward speedups, but warned that selection effects and time-measurement problems made the size of the effect unreliable.[33] The 2025 slowdown is not a timeless verdict on newer agents; the follow-up is not a clean, proven reversal either.
There is also criticism aimed directly at specifications. Brenn Hill’s April 2026 analysis of 119 open-source repositories reported no statistically significant reduction in bug-inducing changes associated with specification artifacts.[34] It is observational research, not a randomized test of this workshop’s method, and its author’s report is not a settled consensus. It still challenges the easy claim that writing a spec automatically prevents bugs.
My hypothesis has to survive those distinctions. A specification can preserve intent and help us test the right behavior. The existence of a Markdown file does not establish that the behavior is correct.
Thoughtworks placed SDD in the Assess ring with a caution attached, and some experienced engineers have tried it and stopped.[4]
InfoWorld’s reviewer doubts that any current tool truly delivers spec-as-source.[11]
Loops burn tokens. Thoughtworks notes that fresh context on every iteration protects quality at significant cost.[35]
More context is not automatically better. Meta points to research in which auto-generated context files lowered agent success on some open-source projects, which is why it keeps each file short.[22]
Microsoft’s own guidance is to automate only what is understood.[13]
Those findings make the experiment more useful. Keep the spec small, give the verifier real authority to reject the work, include review and rework in the cost, and let the result change your mind.
Part Three: Where Specs Meet Loops
Ralph Wiggum & the Dumbest Loop That Works
Geoffrey Huntley described the Ralph technique in July 2025.[36] Its deliberately minimal shape is a shell loop feeding a prompt back to a coding agent:
while :; do cat PROMPT.md | claude ; done
That line illustrates repetition; it contains no success test, spending limit, or network approval policy. The useful workflow comes from the prompt, the artifacts, and the controls around the process: read the current state, attempt a task, run the checks, record the result, and stop or continue under explicit conditions.
It sounds like a joke. It works for three reasons.
Fresh context. Restarting can reduce accumulated noise, provided the next session receives the information it needs. It is a design choice to test, not a guarantee that every reset improves quality.
State on disk. Specs, plans, tests, and handoff notes persist between iterations. The next agent can reconstruct the relevant state without depending on a perfect transcript of the previous session.
Backpressure. Tests, builds, and validators give the loop evidence of failure. The harness must enforce what happens next; an agent can otherwise ignore a failure or weaken a test.
Thoughtworks lists the Ralph loop as a technique on its Radar, and OpenAI names it in its engineering write-up.[35] [21] Implementations differ: a loop inside a session and a wrapper starting a fresh process do not manage context in the same way. Inspect the tool you are actually running. Osmani’s broader point is that durable repository state lets work continue across agent sessions.[37]
- ReadSpec, task list, handoff
- ChooseOne unfinished work unit
- ImplementMake the change
- VerifyRun checks; inspect failures
- RecordResults and next steps
Continue only within the agreed limits. A failure or exhausted budget is a reason to stop and escalate.
Loop Engineering: the Loop Becomes the Product
In June 2026 the practice got a name. Peter Steinberger argued that the skill had moved from prompting agents to building the thing that prompts them: “You should be designing loops that prompt your agents.” Osmani structured the discipline in an essay titled Loop Engineering, and he relays Boris Cherny, who leads Claude Code at Anthropic, saying he no longer prompts Claude himself because his loops do it.[37]
One common way to draw the progression is prompt engineering, then context engineering, then harness engineering, then loop engineering, each layer wrapping the one before it.[38] The Claude Code team now describes four kinds of loops (turn-based, goal-based, time-based, and proactive), with a goal primitive that keeps an agent working until a verifiable condition is met or a bound is reached.[39]
Andrew Ng’s framing is the one I would put in front of every network team. He describes three nested loops. In the innermost, the agent writes, tests, and iterates until the work meets the spec. In the middle, the developer reviews, steers, and updates the spec. In the outermost, feedback arrives from the outside world.[40] [41]
Read that as a network engineer. The spec helps define success, but the harness also needs explicit limits: time, cost, retries, scope, and conditions for stopping and asking a human. A passing test suite supplies evidence for the checks it contains. It does not certify every possible behavior of the network.
Where SDD Plugs In. Directly.
Here is the connection the first two parts were building toward. A loop needs four things from the disk: standing rules, requirements, a task list, and somewhere to leave notes for the next iteration. SDD produces exactly those, with more rigor than a hand-written prompt file. And every one of them has an equivalent that network teams already maintain.
| What the loop needs | What SDD puts on disk | What network teams already call it |
|---|---|---|
| Standing rules for every iteration | constitution.md, layered by organization, domain, and team | Change policy, golden config standards, security baseline |
| Requirements and acceptance criteria | spec.md (the what and the why) | Service intent, design requirements |
| The approach | plan.md, data models, contracts | Low-level design |
| An ordered task list with state | tasks.md, with a checkbox per task | The MOP, step by step |
| Backpressure | Tests, linters, checklists, verification gates | pyATS, Batfish, pre-checks and post-checks, a lab or digital twin |
| Memory between iterations | Task state, a handoff file, a progress log, git commits | Shift handoff notes, the change record |
Now the mechanics. Spec Kit’s implementation stage works through the task list. A long feature may benefit from smaller sessions and durable handoffs, especially when the context becomes crowded. Measure whether that structure helps with your agent and workload.
So the community wired the two together. The Ralph Loop extension for Spec Kit repeatedly spawns a fresh agent. Each new agent reads a compact memory file first, then tasks.md and the design artifacts. It implements and validates one work unit (a single task, a task group, or a whole user story), commits, and exits. The loop continues until every task is committed and the repository is clean.[42] Other projects do the same thing against any tasks.md,[43] and there is a pull request proposing Ralph loop support in the Specify CLI itself.[44] Microsoft’s enterprise write-up notes that Spec Kit workflows can chain commands with human checkpoints, conditional paths, and loops, and can pause and resume when review is required.[13]
The division of labor between the files is the important part. In the Ralph extension, tasks.md is the authoritative record of task state. The memory file carries compact, durable context and the handoff to the next agent. A progress file is an append-only audit history. Committed code carries the implementation itself.[42]
One iteration looks like this:
Wake up with nothing. A fresh context window. No memory of the previous loop.
Read the disk. The constitution, the handoff notes, the task list, and the parts of the spec and plan that matter for the next task.
Pick one unit of work. The next unchecked task. Not three. One.
Do it.
Face the backpressure. Tests, linting, validation. If it fails, fix it or record exactly why.
Write back. Mark the task complete only when its required checks pass. Otherwise record the failure and what remains. Update the handoff notes and preserve the work in version control.
Exit. The context is thrown away. The artifacts stay.
Step 6 is where the compounding happens. Say loop 7 discovers that a lab device rejects a command the plan assumed would work. It finds the right syntax, writes one line about it in the handoff notes, and exits. Loop 8 begins already knowing that, without carrying the 80,000 tokens of trial and error it took to find out.
The agent does not get smarter from one loop to the next. The repository does.
Here is what that looks like for a network change. The layout is illustrative, borrowing Spec Kit and Ralph extension file names:
dc-fabric/
.specify/memory/constitution.md change policy, standards, never-do rules
specs/001-leaf-onboarding/
spec.md what and why, acceptance criteria
plan.md how: platforms, data sources, test strategy
tasks.md [X] T001 ... [X] T014 [ ] T015 ...
ralph-memory.md handoff notes for the next loop
progress.md append-only audit trail
tests/ pyATS, Batfish, pre-checks and post-checks
Anthropic reached this design independently: a spec decomposed into a task list, one feature per fresh agent, structured artifacts as the handoff.[20] OpenAI checks execution plans with progress and decision logs into the repository so agents never depend on outside context.[21]
These implementations share a useful pattern: durable intent, bounded work, and a handoff that another session can read. Their convergence is a reason to study the design. It is not a controlled demonstration that every implementation delivers the same result.
Specification
Plan & tasks
Check
Learn
Handoff notes
Commits
The next iteration reads the updated state. Human judgment and explicit limits govern continuation.
Why this matters to my NetClaw work
With NetClaw, I care about the connection between a statement of intent and evidence from the network. “The command ran” is a weak completion condition. “The required service is reachable, the prohibited path remains blocked, and the management connection survives” gives an engineer something concrete to check.
That is how I want specs and loops to meet the tools I work with: record the intended behavior, gather the relevant state, test the proposed change in a suitable lab or model, inspect the evidence, and obtain the required authorization before execution. A model result and a device observation answer different questions. Preserve that distinction in the change record.
The workshop taught the same habit on a smaller stage. The networking rule had to be right, and a person still had to play the game. A test could verify an OSPF answer while a human discovered that the interface was confusing. Both kinds of feedback belong in the next iteration.
The andon cord, renamed
Backpressure is Toyota’s stop-the-line and TDD’s red bar under a new name. A loop without it produces confident, wrong output faster than any human could.
Network teams are better equipped here than we give ourselves credit for. pyATS snapshots and diffs, Batfish analysis, pre-checks and post-checks, a lab or a digital twin: these are exactly the signals a loop needs in order to know whether a task is actually finished.
Review gates matter too. A team can require approval of intent and the implementation plan, and the cited tools support review checkpoints.[45] [13] Those checkpoints must be configured and enforced. A requirement written in a constitution is not, by itself, a permission boundary.
Humans own the intent and authorization. Agents perform bounded work. Independent checks and human review determine whether the evidence is sufficient to proceed.
Graph Engineering: Loops, Plural
In July 2026 the conversation moved again, from one loop to many. Graph engineering means writing an agent system’s control flow down explicitly: named workers, declared routes between them, and shared state.[46] It is the coordination layer above the loop, and every node in the graph is still a loop.[47] One survey puts it simply: a loop is a graph with a single cycle.[38]
Skeptics point out that state machines and DAGs are decades old and that the new part is mostly vocabulary.[47] They are right, and for network engineers that is the good news.
SDD fits in two ways. First, the SDD lifecycle is already a graph: specify, clarify, plan, generate tasks, implement, verify, with human checkpoints on the edges. Second, the spec artifacts are the shared state that travels along those edges, so a planning agent, a building agent, and a reviewing agent all work from the same written intent instead of each other’s chat history. Osmani’s advice on structure applies here: separate the agent that writes from the agent that checks, because a model grades its own homework too kindly.[37]
We have been drawing these graphs for years. Pre-check, approve, execute, post-check, roll back on failure. We called them workflows. Graph engineering is that picture with one change: some nodes are deterministic steps, and some are agent loops working from a spec.
- Human reviewApprove intent and scope
- PlanChoose tasks and checks
- Build loopImplement and record
- VerifyIndependent tests and review
- DecisionAccept, revise, or stop
All participants work from the same specification and evidence. Production execution needs its own authorization.
Compress the Timeline
Step back and look at the whole road.
| Era | What was scarce | Where intent lived | Feedback |
|---|---|---|---|
| Waterfall | Compute, and the ability to change | One large up-front document | Months |
| Lean | Inventory and rework | Standard work | Per unit, stop the line |
| Agile and TDD | Developer time | Tests, backlogs, and heads | Days to minutes |
| NetDevOps | Operator time | Code, source of truth, pipelines | Per commit |
| AIOps and MLOps | Attention | Models and dashboards | Continuous, often advisory |
| AgenticOps | Human judgment | Specs on disk | Every loop |
Across these eras, the recurring problem is preserving intent while learning from implementation. Specs and loops let us try a new balance. The useful question is whether that balance improves the work we actually do.
Run an experiment your team can challenge
If you want to start on Monday, take the curiosity from AC6 and give it a fair test:
Define the claim before the result. Choose a small, familiar lab change, such as a VLAN rollout or leaf onboarding. Write down the expected behavior, forbidden outcomes, and what improvement would justify adopting the method.
Make a fair comparison. Use several comparable tasks with the usual workflow and with SDD plus a bounded loop. Where practical, randomize task assignment or alternate the order. Keep the tool versions and acceptance checks recorded. To isolate the value of SDD, compare against the same AI tool used without the structured workflow, too.
Make the checks independent of the implementation. Establish expected results before building. Use pyATS, Batfish where its model applies, service checks, and a reviewer who can reject the change. Include edge cases and recovery. Do not let the agent redefine success to make a failing task pass.
Count the whole job. Record time to an accepted result, human review minutes, rework, failed checks, defects found after acceptance, and tool cost. For delivery, track lead time and change failures. For security, track findings by severity and time to fix. A faster first draft is only one measurement.
Keep the trial bounded and publish the outcome. Set a time and spending limit, define when the loop must stop, and keep production authorization with the responsible people. Save the spec, commits, test outputs, and failures. Repeat before generalizing, and report a disappointing result as clearly as a successful one.
For a first exercise, use the AC6 workshop repository. The Microsoft Learn module and GitHub’s Spec Kit introduction provide another starting point.[48] [9] Read the tool’s current instructions, pick a small project, and keep the result and its evidence together.
Then bring your manager the artifacts: what the task required, what the agent did, what the checks found, what the reviewer changed, and what the whole effort cost. The AC6 participants already understood the value of having something concrete to show. This is how I would extend that instinct into a defensible engineering decision.
I watched people move from “What the hell is SDD?” to sharing something they had built in a day. I want more engineers to have that experience. I also want the people who remain unconvinced to have the time, sources, and practical tests they need to reach their own conclusion.
The SHAZAM moment gets your attention. What survives inspection earns your confidence.
Don’t take it from me. Read them. Question them. Try it. Measure it. Let the evidence tell you what to do next.
Sources & Further Reading
Numbered in order of first citation. Entries after the last cited number are additional reading from the same research.
Network Automation Forum. AutoCon 6, Tucson, November 16 to 20, 2026. Workshop WS:C1, Loop Engineering, Spec Driven Development, and the Future of VibeOps. Read the source
Back to articleJohn Capobianco. I hoped for six games. They built an arcade. November 20, 2026. Workshop recap, participant accounts, playable games, and lecture materials. Read the source
Back to articleJohn Capobianco and contributors. NetClaw. Open-source network engineering agent and project documentation. Read the source
Back to articleTaskade. What Is Spec-Driven Development? Tools and Evidence (2026). November 13, 2026. Read the source
Back to articleMicrosoft Developer Community Blog. Moving Beyond Prompts: A Practical Introduction to Spec-Driven Development. May 5, 2026. Read the source
Back to articleMicrosoft for Developers. Spec-Driven Development: A Spec-First Approach to AI-Native Engineering. June 10, 2026. Read the source
Back to articleIBM Think. What Is Spec-Driven Development? Read the source
Back to articleDen Delimarsky, Microsoft for Developers. Diving Into Spec-Driven Development With GitHub Spec Kit. September 15, 2025. Read the source
Back to articleThe GitHub Blog. Spec-driven development with AI: Get started with a new open source toolkit. September 2, 2025. Read the source
Back to articleDeepak Babu Piskala. Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants. arXiv:2602.00180, 2026. Read the source
Back to articleMartin Heller, InfoWorld. 4 cutting-edge tools for spec-driven development. May 15, 2026. Read the source
Back to articleMicrosoft Inside Track. Engineering the Frontier Firm: Sharing our AI-native approach to software development. Read the source
Back to articleApoorv Gupta, Microsoft for Developers. From Spec-First to Enterprise-Ready: Extending GitHub Spec Kit. October 7, 2026. Read the source
Back to articleAWS. Introducing Kiro: A new agentic IDE that works alongside you from prototype to production. July 14, 2025 (link is to the AWS Japan translation). Read the source
Back to articleAWS Builder Center. Kiro Specs: Stop improvising and start planning features with AI. Read the source
Back to articleAWS re:Invent 2025. Spec-driven development: Shaping the next generation of AI software (DVT212). Session transcript. Read the source
Back to articleGoogle Developers Blog. Conductor: Introducing context-driven development for Gemini CLI. December 17, 2025. Read the source
Back to articleGoogle Developers Blog. Evolving Spec-Driven Development: Conductor Now Supports Antigravity. July 16, 2026. Read the source
Back to articleAnthropic Engineering. Effective harnesses for long-running agents. November 26, 2025. Read the source
Back to articlePrithvi Rajasekaran, Anthropic Engineering. Harness design for long-running application development. March 24, 2026. Read the source
Back to articleRyan Lopopolo, OpenAI. Harness engineering: leveraging Codex in an agent-first world. February 11, 2026. Read the source
Back to articleEngineering at Meta. How Meta Used AI to Map Tribal Knowledge in Large-Scale Data Pipelines. April 6, 2026. Read the source
Back to articleJake Nations (Netflix). The Infinite Software Crisis. AI Engineer talk, December 2025. Read the source
Back to articleSean Brandt, GEICO Tech Blog. An Introduction to Spec-Driven Development. Read the source
Back to articleSimon Martinelli. Spec-Driven Development: From Specs to Code with AI Agents. Apress Pocket Guides, 2026. Read the source
Back to articleWikipedia. Specification-driven development. Read the source
Back to articleCui, Demirer, Jaffe, Musolff, Peng, and Salz. The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers. June 2025. Randomized field experiments; 4,867 developers. Read the source
Back to articleJared Bauer, GitHub. Does GitHub Copilot improve code quality? Here’s what the data says. November 18, 2024; updated February 6, 2025. Vendor-run randomized study; 202 valid submissions. Read the source
Back to articleNagappan, Maximilien, Bhat, and Williams. Realizing quality improvement through test driven development: results and experiences of four industrial teams. Empirical Software Engineering 13, 289–302 (2008). DOI: 10.1007/s10664-008-9062-z. Comparative industrial case studies. Read the source
Back to articleMike Hanley, GitHub. Found means fixed: Secure code more than three times faster with Copilot Autofix. August 14, 2024; updated January 21, 2025. Vendor-observed May–July 2024 public-beta remediation times. Read the source
Back to articleNathen Harvey, DORA. DORA 2025: Year in review. January 7, 2026. Research summary covering delivery throughput and stability. Read the source
Back to articleBecker, Rush, Barnes, and Rein, METR. Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. July 10, 2025. Randomized trial; 16 developers and 246 tasks. Read the source
Back to articleBecker, Rush, Cunningham, Rein, and Mahamud, METR. We are Changing our Developer Productivity Experiment Design. February 24, 2026. Follow-up results and selection and measurement limitations. Read the source
Back to articleBrenn Hill. I Tested Whether Specs Prevent Bugs. They Don’t. April 7, 2026. Author’s account of observational research across 119 repositories, with links to the working paper and analysis pipeline. Read the source
Back to articleThoughtworks Technology Radar. Ralph loop (technique). Read the source
Back to articleGeoffrey Huntley. Ralph Wiggum as a “software engineer.” July 14, 2025. Original description of the Ralph technique. Read the source
Back to articleAddy Osmani. Loop Engineering. June 7, 2026. Read the source
Back to articleThe Hitchhiker's Guide to Agentic AI: From Foundations to Systems. arXiv:2606.24937, 2026. Read the source
Back to articleAddy Osmani. Practical Loop Engineering. August 14, 2026. Read the source
Back to articleADTmag. Loop Engineering Emerges as Developers Put AI Coding Agents on Repeat. July 1, 2026. Read the source
Back to articleAI Builder Club. Loop Engineering Guide (2026), summarizing Andrew Ng's three-loop model. Read the source
Back to articleSpec Kit community extensions. Ralph Loop: autonomous implementation loop for Spec Kit. Read the source
Back to articleT-0-co. speckit-ralph: Ralph Loop with Spec Kit command and control layer. Read the source
Back to articlegithub/spec-kit pull request #1489. Ralph Loop support in Specify CLI. Read the source
Back to articleAWS builders.flash. Organizing the evolution of spec-driven development in Kiro. June 2026 (in Japanese). Read the source
Back to articleDataCamp. What is Graph Engineering? A Hands-On Guide to Multi-Agent Orchestration With LangGraph. September 24, 2026. Read the source
Back to articleAI Builder Club. Graph Engineering vs Loop Engineering. Read the source
Back to articleMicrosoft Learn. Training module: Introduction to spec-driven development with GitHub Spec Kit (greenfield). Read the source
Back to articleIan Hernandez, DreamHost. The Ralph Wiggum Loop, From First Principles. Read the source
Clayton Farr. The Ralph Playbook. Read the source
Lee Stott, Microsoft Educator Developer Blog. Spec-Driven Development for AI-Enabled Enterprise Systems. May 18, 2026. Read the source
Microsoft Educator Developer Blog. Prompt Engineering for Spec-Driven Development with SpecKit. April 20, 2026. Read the source
Addy Osmani, O'Reilly Radar. How to Write a Good Spec for AI Agents. Read the source
Microsoft for Developers. Agentic Agile: Why agent development needs Agile, not just prompts. May 19, 2026. Read the source
Anthropic. Claude Code product page. Read the source
Microsoft for Developers. All posts tagged Spec-Driven Development. Read the source


