Worklog for task "New planning system"

After several hours of experimenting with the new planning system, I gained a much better understanding of both the limitations of the current implementation and the limitations of the AI-agent-driven development approach itself. The agent implemented some parts successfully, but overall the system does not yet meet my requirements, and further local fixing of individual issues is no longer efficient.

Particularly revealing was the attempt to regress and simplify the system. The agent was explicitly instructed which parts of the implementation should be removed or simplified, but along with them, it also touched other elements that were supposed to be preserved. This highlighted an important limitation: the agent is capable of working with individual fragments and local dependencies, but struggles to maintain the boundary between targeted simplification and the destruction of interdependent behavior. When a system consists of several interconnected subsystems, locally sensible changes can disrupt connections that were not explicitly described in the current context.

This leads to a more general conclusion about AI-assisted development. If an agent starts repeatedly fixing the consequences of its own previous changes, continuing such a cycle quickly leads to an accumulation of code, workarounds, and implicit dependencies. At some point, the problem is no longer a specific bug, but the loss of a simple and verifiable model of the system. Trying to task the agent with deep refactoring in such a state carries the risk of further increasing complexity: it may correctly optimize individual sections without understanding which properties of the entire system must remain unchanged.

Therefore, the development phases need to be rethought. Probably, the main object of control should shift from the internal implementation to the external behavior of the system: requirements, invariants, scenarios, tests, and relationships between subsystems. If the implementation ceases to meet these requirements and the agent cannot quickly return it to a correct state, it may be more advantageous not to continue the endless repair-loop, but rather to fix the desired behavior, simplify the model, and rebuild the implementation from scratch. In other words, code in such a process should be viewed more as a replaceable artifact rather than an asset that must be preserved at all costs and patched up gradually.

The experiment proved useful precisely because it revealed the limit of local AI refactoring: it is difficult for the agent to independently determine where permissible simplification ends and the destruction of system relationships begins. The next stage of work should be built around a more explicit specification of behavior and subsystem boundaries, rather than around further fixing the already accumulated implementation.