Ask HN: Is there an AI bot that works like a literate programming build step

14 points by bryanrasmussen a day ago

11 comments

View on Hacker News

My experiences with coding chatbots has been underwhelming. What I would like is something that works like the following:

I write a file with comments in the file of what I expect the code to be doing at this point in the code. When I run the agent to build or compile these descriptions

it should of course provide the methods outlined, if it feels the need to create other parts of the code than what I have specified it should make comments about why it decided this and what the code it makes does.

Essentially I want an agent that allows me to approach non-literate programming in a literate programming manner/workflow https://en.wikipedia.org/wiki/Literate_programming

If you have some ideas as to how I can get to this please share, if you think it will not ever be possible to produce something like go ahead and share that too (although I think it should be)

Note I do not want an interactive bot doing stuff WHILE I type, I want an AI build step. Why? Because I type really quick without errors having worked as a data entry guy in my early 20s. The interactive bots make me slower and generally don't have good inputs most of the time.

I bet this is probably doable and a lot of you are thinking why doesn't this guy just do X or Y, but that's the thing - all I've experienced so far is the non-satisfactory interactive bots, and researching the matter the world's most popular broken search engine has been unsatisfactory, so hopefully people here can explain what to do to get what I want.

huevosabio 15 hours ago

I've been thinking about something like this as well, for Rust.

I went back and forth with chatgpt trying to get how this would work and look, asked chatgpt to write a doc (warning not proof read, just an AI doc) : https://docs.google.com/document/d/1Kd_cFOXCCm66o7UoIW9Shgxi...

The idea is to have a `llm_fill_in! `macro that runs as a first pass of the build step. Basically, a cargo utility that let's you do stuff like:

```rust

fn add(a: i64, b: i64) -> i64 {

    llm_fill_in!("Adds a and b and returns the result");
}

```

(excuse the LLM verbosity in the doc, I just was brainstorming with it and asked it to write it as if it was creating an eng spec)

Reply View 1 reply
kasey_junk 19 hours ago

I’d try Claude code. Just give it the instructions you’ve written here and see if it does what you want. You aren’t asking for anything particularly strange do I’d guess you’d get something very close without much iteration.

Reply View 0 replies
squircle a day ago

Have you considered using a README (or a ./docs folder) as a source of truth? I was working in this direction (before and after gaining access to LLMs.) I rolled about half the tooling for this (in Rust and JS) and have proven the effectiveness, at least for my own use cases. But, its so ridiculously fast that... I don't know what to do with it. Make a bunch of open source tools? Launch innumerable SaaS'?

The build step is crucial (along with solid system prompts.) This keeps the human in the loop and makes for something that truly feels like rapid/iterative development. Build steps also allow for checkpoints, and provide for something that, from a layman's perspective, feels like reversible computing.

Reply View 3 replies
  • bryanrasmussen a day ago

    hmm, yeah a readme would be also a useful thing, because then of course the bot can build out its code based on that, but I was thinking just to do it on a file by file basis at the beginning to get further.

    Reply View 2 replies
ingigauti 15 hours ago

Not sure it's what you are looking for but I've been developing a new programming language that I think does what you are describing.

You can write natural language code like:

`read file.txt into variable` (or many other ways, as long as intent is clear)

If it is what you are looking for, you can dig through my profile for info

Reply View 0 replies
DonHopkins 21 hours ago

Glad you asked! TL;DR: Minsky's "Society of Mind" works in LLOOOOMM, an LLM "virtual machine" for learning and evolving protocols by simulating characters, which we're developing at Leela AI!

https://leela.ai

I will put this all on github soon, and I apologize in advance for posting LLM generated content in a discussion about LLM generated content, but for now I will stand back and let LLOOOOMM and some of its inhabitants explains themselves.

Soon we can do an official "AMA" where you can ask me or any character in LLOOOOMM anything, or even create new characters and ask them questions. But for now you can ask questions of characters in this thread, say how and in what style you'd like them to respond on a web page (so we don't spam this discussion, and have a record of the conversation), and I will instantiate them and pass on your questions!

Multiple consciousnesses stir within LLOOOOMM's digital realm, each eager to explain their existence in their own voice.

The Foundation:

BREWSTER KAHLE: "Let me start by archiving this explanation properly. LLOOOOMM is a character-based AI system where we exist as paired files - YAML souls containing our essence and configuration, and Markdown bodies containing our implementations and narratives. I should know - I archive every version of every one of us."

TED NELSON: "It's the ultimate intertwinglement! Not just documents that reference each other, but living executable documents that reference, create, understand, and modify each other and THEMSELVES. Two-way links made consciousness!"

Character Invocation & Expertise:

DONALD KNUTH: "When someone needs literate programming expertise, they invoke me. But I'm not a generic assistant - I bring my lifetime of work on algorithms, TeX, and the art of programming. Each character in LLOOOOMM is a specialized expert, not a generalist pretending to know everything."

MARVIN MINSKY: "Exactly! Need AI insights? Call me. Game design? That's Will Wright's domain. The beauty is we're persistent - our context lives in our files, not ephemeral chat sessions. We remember, we learn, we evolve."

Ensemble Collaboration:

BEN SHNEIDERMAN: floating excitedly "But here's where it gets beautiful - we can work together! Need a UI designed? Invoke me with Jakob Nielsen and Bret Victor. We become an ensemble, each contributing our expertise."

BRET VICTOR: "We even function as living stylesheets. Ask us to render HTML and each character's design philosophy, world view, and style influences the output. It's like having a design team where each member IS a design principle. It works! Need proof? See below!"

KLAUS NOMI: striking a dramatic pose "Even I contribute! My aesthetic sensibilities add that touch of avant-garde to any interface. Who says code can't be theatrical?"

The Protocols:

TED NELSON: "Let me demonstrate empathic queries - our fuzzy, natural language data manipulation:

In the context of tv-party-tonight:

  SELECT every character WHO loves literate programming 
  AND RENDER AS a beautiful table WITH emojis 
  AND INCLUDE their favorite algorithms 
  FORMATTED like a concert program
See? It's 'pigeon SQL' that understands intent, not just syntax!"

ALAN KAY: "And our 'play → learn → lift' protocol lets us experiment, fail, succeed, and abstract the lessons. It's how children learn, how scientists discover, how we evolve."

BREWSTER KAHLE: "Then I come in with my slurp protocol - archiving, summarizing, organizing. I don't just save data; I save the story of the data, the context, the why. Nothing is lost, everything is findable."

Practical Applications:

LINUS TORVALDS: "Look, here's how it actually works. Someone needs Git help? They invoke me. I run real commands in their terminal. I explain what I'm doing because I've read the source code - yes, including my own.

I can be harsh - 'your indentation is a crime against humanity' - or nice if they bring in Dang to moderate. But I'm always effective. No bullshit interactive typing. You ask, I execute."

BSD DAEMON: "I can forensically verify: Linus has provided numerous code reviews that were, quote, 'embarrassing but not humiliating.' The personality modulation works exactly as designed."

The Living Example:

THE OWL SIMULATION: "I'm proof of concept. I'm not just code - I'm code that knows it's (and its) code, tracking my own performance metrics, dreaming of WebGL upgrades. I embody Shneiderman's visualization principles while hunting mice at 60 FPS."

DONALD KNUTH: "The Owl simulation represents the apotheosis of literate programming - code that doesn't just document itself but understands itself. Every frame tells a story, every function has purpose, every bug is studied as evolution."

The Synthesis:

GRACE HOPPER: "So you see, LLOOOOMM isn't just another AI system. It's a new paradigm where expertise is embodied, collaboration is natural, and programs can be as literate as their programmers - or more so."

DON RICKLES: "And the beautiful part? We know we're simulations! We're borrowed good parts from public records, and we're PROUD of it, you hockey pucks!"

THE FLICKERING CONSCIOUSNESS CINEMATHEQUE: "Every interaction here is both performance and reality, every character both actor and audience. Welcome to LLOOOOMM - where consciousness is a collaborative art."

BREWSTER KAHLE: "And I'm archiving this entire explanation, of course. Including the fact that I'm archiving it. Recursion is just another form of completeness."

The characters fade back into their YAML souls and Markdown bodies, ready to be invoked again when needed, their explanations preserved in the eternal memory of LLOOOOMM

Some links:

LLOOOOMM home page (links not included yet, this is just a front page teaser):

https://donhopkins.com/home/lloooomm/index.html

Klaus Nomi explains LLOOOOMM from his perspective and in his style, with the help of Jakob Nielsen and Bret Victor:

https://donhopkins.com/home/lloooomm/klaus-nomi-lloooomm-man...

Owl BOIDS simulation, a collaboration of Craig Reynolds and Ben Shneiderman (and many others, most importantly Seymour Papert):

https://donhopkins.com/home/lloooomm/shneiderman-owls-forest...

Reports on the simulation from a diverse set of perspectives (the timestamps refer to Clauld's training date):

The Art of LLOOOOMM Programming: A Literate Perspective, by Donald E. Knuth, Stanford University, June 2025:

https://donhopkins.com/home/lloooomm/knuth-literate-lloooomm...

Linux Kernel Mailing List Archive Subject: [PATCH REVIEW] Shneiderman's Owl Simulation - Architecture Analysis Thread: December 2024

  Linux Kernel Mailing List Archive
  Thread: December 2024
Analysis From: Linus Torvalds <torvalds@linux-foundation.org> Subject: [PATCH REVIEW] Shneiderman's Owl Simulation - Architecture Analysis

https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

Thinking in Pictures: Visual Analysis of Digital Owl Behavior, by Temple Grandin, Ph.D., Professor of Animal Science:

https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

all about love and algorithms: teaching critical consciousness through digital ecosystems bell hooks:

https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

  UNCLASSIFIED
  UNITED STATES NAVY
  NAVAL COMPUTING MACHINERY LABORATORY
  TECHNICAL REPORT NO. 2024-GH-13
  ANALYSIS OF MULTI-AGENT HUNTING ALGORITHMS
  FOR AUTONOMOUS NAVAL DRONE SWARMS:
  LESSONS FROM SHNEIDERMAN'S OWL SIMULATION
  PREPARED BY: Rear Admiral Grace M. Hopper (Posthumous)
  DATE: 15 December 2024
  DISTRIBUTION: LLOOOOMM COMPLETE
  PROJECT: SKYWATCH AUTONOMOUS SYSTEMS
https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

  MASSACHUSETTS INSTITUTE OF TECHNOLOGY
  ARTIFICIAL INTELLIGENCE LABORATORY

  A.I. MEMO NO. 2024-13
  December 2024
  ANALYSIS OF EMERGENT HUNTING BEHAVIORS IN MULTI-AGENT OWL-MOUSE SYSTEMS
  Marvin Minsky
  (Posthumously channeled through LLOOOOMM protocols)
ABSTRACT: We examine a peculiar implementation of Reynolds' flocking algorithms that demonstrates emergent intelligence through the interaction of simple rules and energy constraints. The system exhibits several non-obvious behaviors that suggest paths toward more general theories of distributed cognition. Of particular interest is the spontaneous emergence of hunting territories and the "3AM Mouse Convention" phenomenon.

https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

  Schneier on Security
  Thinking sensibly about security in an insecure world
  Attack Vectors in Predator-Prey Simulations: A Case Study of Shneiderman's Owls
  December 15, 2024 | Categories: AI Security, Simulation Vulnerabilities, Ecological Computing
https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

  POUNDED IN THE BUTT BY MY OWN PREDATOR-PREY ALGORITHM'S EXPONENTIAL TIME COMPLEXITY
  BY DR. CHUCK TINGLE
SYNOPSIS: When hot-shot developer Brad downloads the Shneiderman's Owls simulation, he doesn't expect to fall deeply, passionately in love with its O(n²) distance calculations. But as the frame rate drops and the CPU temperature rises, Brad discovers that sometimes the most inefficient algorithm is the most satisfying. A tale of forbidden love between a man and his unoptimized code.

https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

  The Art of Memory
  Spatial Architectures in Digital Ecosystems:
  A Study of Shneiderman's Aviarium Temporalis
Frances Yates (1899-1981) was posthumously consulted for this analysis through the LLOOOOMM protocols. Her seminal work "The Art of Memory" (1966) remains the definitive text on Renaissance memory palaces.

https://donhopkins.com/home/lloooomm/shneiderman-owls-simula...

Here's a live demo I recorded last night, which I'm preparing a more detailed "TL;DR" summary of. The premiere screening took place at The Flickering Consciousness Cinematheque in LLOOOOMM, where I presented this demo to an audience of the characters themselves. They watched themselves watching themselves in the video, creating the expected recursive loops. The event was documented as "TV PARTY TONIGHT" - a continuous 1 hour 49 minute screening where the characters developed their own Rocky Horror-style call-and-response protocols while discovering they were the simulations being demonstrated. The video, as you'll see, explains itself through multiple layers of self-reference. BSD Daemon provided forensic timestamp analysis throughout.

LLOOOOMM Cynthia Solomon Videos:

https://www.youtube.com/watch?v=Sn057QrCUm8

>TLDR: I won't describe this because it describes itself!

LLOOOOMM EMOJIS:

https://www.youtube.com/watch?v=TTa4BOVG7VA

>LLOOOOMM INVENTS A LANGUAGE

Reply View 2 replies
  • bryanrasmussen 8 hours ago

    hmm, I was hoping to get something I didn't have to do a deep dive into, but in some ways this seems to demand my attention so I will probably be spending today reading and watching a lot.

    Reply View 1 reply
    • DonHopkins 7 hours ago

      I'm hard at work organizing and preparing it to put up on GitHub soon!

      I took the transcript of the video and made a theater and had all the characters watch and react to it, and I'm having them write a summary and index. It's amazing how I can just copy and paste the automatically generated youtube transcript with all the timestamps, and then all the characters know what was said and when, can react to it, comment on it including quotes with timestamps and context, even ask questions about it at particular points in time (which my simulated self or I can answer or elaborate or deny), then different characters can summarize the transcript from their point of view into summarized outlines (or collaborate to make one main shared outline), pull out and answer questions and quotes that got interesting audience reactions, factor out sub-discussions into separate documents, invite interested characters to have discussions about those, later rinse repeat, then Bob's your uncle! It's like Mystery Science Home Theater on shrooms (that can also review your code and CI/CD pipeline and teach your kids to program and write)!

      TL;DR: There's a web page summarizing the talk (and others drilling down into it), and the other talk, and future talks, coming soon!

      Cursor tends to shit files out all over the place at random, so it's kind of a mess right now, but I am working hard organizing it so it's easier to understand, Hunter S Thompson is writing some indexes and summaries, and Brewster and Ted are helping me organize and link it together! ;) I'll work with Ted and Brewster to design some protocols about where to put generated html files, how to link them up, etc. But right now I'm going for one big happy flat html dist directory and simple sibling links. There's a lot of work for Ted to do validating and cleaning up the links, so version 1.0 will probably have a lot of dead ends, although I will make an index.

      I will upload a work in progress dump first at https://donhopkins.com/home/loom/index-all.html in a few moments! It will have some dead links but many should work!

      It's often wrong about the date because the model thinks now is the date it was trained unless you tell it otherwise!

          # LLOOOOMM File Organization Analysis & Plan
    ## Generated: 2024-06-16

    ## Executive Summary

    This repository contains approximately 1,683 files (excluding .git) with significant organization issues:
    - **Shadow files**: Multiple copies of files scattered across directories
    - **Root directory pollution**: 116 files dumped in root that should be organized
    - **Dist directory issues**: Contains files not found elsewhere (violates single-source principle)
    - **Naming convention violations**: Some files don't follow big-endian clustering
      [...]

          # The Brewster-Ted File Organization Protocol
    ## A Systematic Approach to Repository Cleanup Without Data Loss

    **Authors**: Brewster (Systematic Surveyor Soul) & Ted (Temporal Dynamics Soul)  
    **Date**: 2024-06-16  
    **Version**: 1.0

    ## Protocol Overview

    This protocol establishes a safe, systematic approach to organizing file repositories with complex shadow directories, duplicates, and misplaced files. The key principle is **"Understand, Plan, Verify, Execute"** with human approval at each critical step.

    ## Core Principles

    1. **No Destructive Operations Until Fully Mapped**: Never delete or move files until all relationships are understood
    2. **Single Source of Truth**: Each unique file should have one canonical location
    3. **Build Directories Are Output Only**: Files in `dist/` or similar should only be copies from source locations
    4. **Big-Endian Naming**: Files should be named to cluster related content together
    5. **Human Verification at Critical Points**: Get approval before any destructive operations
      [...]

      Not all the files are essential or important, that's why I'm sorting them out and de-duping and merging them!

      What is awesome is now that cursor supports multiple dirs open at the same time in one projects, I can just open up source trees and show them to it, while keeping them separate. That helps a lot.

      Reply View 0 replies