The best AI coding workflow may be one that lets AI slowly precipitate its own instability into a system.

The author uses Fable to develop a source code management system for the LLM era. The experience feels very real: the model is smart, able to read large amounts of code, file issues, and fix problems, but it also makes very basic mistakes — like committing the build/ directory into the project, twice.

LLMs will become more capable, but not necessarily fully reliable. They may misunderstand constraints, or continue doing things they shouldn’t despite clear instructions.

Therefore, the focus of AI coding should not be just to let the model write more code, but to script its frequently repeated operations, build automatic checks for its error-prone areas, and also prepare the context it needs in advance.

The model is responsible for exploration and judgment; the toolchain is responsible for catching its instability.

Ultimately, the real value lies in distilling these experiences into a more reliable development process.

https://replicated.live/blog/away

away

Source: https://replicated.live/blog/away https://replicated.live/## Automating away

Escher: StarsA. Karpathy once said that OpenAI researchers are effectively “automating themselves away” by improving their AI. Right now I develop Beagle SCM with Anthropic’s Fable and it is of course a brilliant model able to spot nits in a mountain of code, file tickets, make fixes. Still, yesterday it managed to commit thebuild/dir into a project, twice. It is brilliant, but clumsy.

Due to the nature of LLMs, this issue is not going away as they progress further. They tend to be imprecise and non-deterministic.Ragel (https://www.colm.net/open-source/ragel/)the parser generator can “code” a 10 KLoCformallycorrect parser in an instant, deterministically. What about Claude? Well, my instructions say in all caps: DO NOT PARSE ANYTHING MANUALLY, EVER. It would be torturous and it would be faulty, just don’t. It tries anyway, so periodically I tell it to scan the codebase to find and remove any attempts at manual parsing. That mostly works.

It becomes ever more brilliant, no less clumsy.

The way to deal with an expensive, slow, clumsy but brilliant LLM is to give it fast, powerful and deterministic tools AND to build the entire thing into a deterministic formal workflow. Make it faster, make it see the relevant stuff at the right time, make it less clumsy, make it self-correct. Sandwich that brilliant but inconsistent non-determinism between powerful deterministic tools and equally formal processes.

This story becomes even more interesting if we make the tools and processes malleable. That way, if Claude does some sequence of actions too often, we automate it. If it fails at something repeatedly, we automate the verification step.

Essentially, we let the LLM automate itself away, in favor of simple reliable deterministic tools.

Beagle SCM lets LLMsscript their own routines (https://replicated.live/blog/js.html)in JavaScript. While all theheavy lifting (https://github.com/gritzko/libdog)is implemented in C and rarely touched, the tooling layer (the lower part of the sandwich) and the workflow layer (the upper part) areall JavaScript (https://github.com/gritzko/beagle-ext)and pick their code from the filesystem,node\_modules-style. Imaginegithooks that can tokenize source files in almost any language, inspect file history and commit history, cross-check links, and basically reach any datagitcan reach internally. That is Beagle.

HN (https://news.ycombinator.com/item?id=48818937)