How to build loops for real-world codebases

TL;DR

Control loops guide incremental changes in a codebase instead of giant PRs. A sensor identifies the current state, a controller decides the next small change, and an actuator applies it, with feedback to avoid destabilizing the system. This approach makes complex migrations readable, safer, and more manageable for teams with real customers and regulators.

Transcript

[music] [music] Hey everybody, my name is Kyle. Hums are really powerful, don't get me wrong, but so much of the discourse around them is hype and just really not helpful, right? We I think we have this idea just kind of as an industry somehow that we can like pipe a prompt and a loop to a coding agent and that we can build software this way, right... Read More

Key Insights

• A control loop is a feedback system that moves a codebase toward a desired end state.
• A sensor detects the current state of the system and reports it to the controller.
• The controller decides the next small change to apply, reducing risk of large, destabilizing updates.
• An actuator implements the chosen change within the codebase.
• Incremental changes are verified through deterministic CI and version control.
• Grep and other tools can serve as practical sensors to find unmigrated procedures.
• Ralph style loops should be combined with control theory to avoid unreviewable PRs.
• The approach supports migrating complex projects one procedure at a time, even across multilingual repos.

Questions & Answers

Q: How to implement a control loop for code migration

A control loop starts with a sensor that identifies unmigrated procedures, a deterministic rule set that defines criteria, and a controller that selects the next small change to migrate. An actor applies that change in a single iteration, after which feedback is gathered to measure progress and adjust the next move. This keeps changes incremental, reviewable, and aligned with a stable end state.

Q: What role does a sensor play in this approach

The sensor detects current conditions in the codebase, such as unmigrated procedures or policy conformance. It can be a deterministic tool like Grep or eslint based rules, or a non deterministic agent. The essential function is to produce a list of actionable items for the controller to prioritize, enabling incremental progress without large, unreadable diffs.

Q: Why are small incremental changes preferred over large PRs

Big PRs are hard to review, risk destabilizing the system, and often fail to meet compliance needs. Incremental changes reduce risk by allowing verification at each step, keeping the system close to a stable end state. This aligns with control theory where gradual adjustments prevent overshoot and maintain reliability.

Q: How does version control contribute to the loop process

Version control records every incremental change and allows the loop to refuse stacking new updates while an earlier one is open. This creates a predictable, auditable sequence of small migrations. It also enables deteministic checks at each PR, ensuring that only compliant, verified changes are merged.

Q: What is the function of a controller in this framework

The controller evaluates sensor outputs and chooses the next incremental change to apply. It aims to reduce the measured error between current state and desired end state. By prioritizing small, verifiable steps, the controller minimizes risk and improves the chances of a stable migration path across the codebase.

Q: Can you migrate a multilingual monorepo with this method

Yes, the approach is language agnostic and can scale to multilingual monorepos. By using a language independent sensor and deterministic inclusion rules, unmigrated procedures across different languages can be identified and migrated in a controlled sequence, maintaining consistency and reducing the risk of cross language integration issues.

Q: What is meant by a deterministic scan in this context

A deterministic scan produces the same ordered list of violations or unmigrated items given the same input state. This predictability is crucial for reliable review, CI checks, and version control. It ensures that each PR follows a consistent path toward the end state and that outputs can be reproduced.

Q: How does this relate to existing tools like Ralph loops

Ralph loops are a concept for prompting or guiding agents, but this approach integrates control theory to manage those prompts and changes incrementally. It emphasizes that good loops leverage sensors, controllers, and actuators to ensure changes are safe, reviewable, and aligned with a defined end state, rather than deploying large, unreviewed diffs.

Summary & Key Takeaways

• A control loop uses a sensor to measure current state and a controller to decide incremental changes, applying them through an actuator. This method reduces risk by avoiding large, unreadable diffs and supports gradual migration in complex, real world codebases.

• In practice, the loop migrates procedures one by one, using deterministic feedback and version controlled PRs to verify each step. The process is designed to keep changes readable and verifiable while maintaining system stability and meeting constraints like SLAs and compliance.

• The talk argues that loops designed with control theory can outperform naive, blind prompting by ensuring each iteration moves the system toward a desired state without oversteering or breaking existing functionality.