When the LLM writes a description of a codebase, you are doing transformation from more semantic meaning to less semantic meaning, and you by definition lose some details.

When you go from requirements to code, transformation is from from less semantic meaning to more semantic meaning. The the missing semantic meaning has to be invented. When inventing the missing semantic meaning, the success depends on what the LLM has trained on.

There could be open source tooling to create custom private "closednets", with

- trust ring mechanism to allow invitations, flagging, banning, and banning those that invite people who were banned

- the rules of the closednet

- search engine with opt-in scraping

- portal (remember the 80s?) with all the registered nodes, perhaps by service category such as public git repo hosts, web sites etc.

etc.

The first closednet could be Hacker News.

Related to this, I created a tool for situations where you want to compare COBOL code with Java code. It includes a preprocessing step where IMS etc. calls are converted to mocks that return JSON (from file), and also use JSON for input/output, and GnuCOBOL to run the program. More a proof-of-concept than production, but here is a link if somebody finds it helpful.

https://github.com/mikko-ahonen/coboltwin

Intermediate representations are often used to keep the architecture more manageable -- in compilers, for example. But these internal representations appear to increase expressability, which goes beyond the architecture.

For example, software development development cycle has several transformations: from requirements to user stories to design, and then to code. The stages are getting a revival, because they appear to be helpful when working with LLMs.

If we think LLMs as transformation machines, the transformation is reliable to the extent the source internal representation can capture the explicit semantics. The less LLM needs to make up in the content, the more reliable the end result.

This is close to how LISPers approach coding: invent a DSL for what you want to do, implement it in your DSL, and then implement the DSL. This approach seems to work well when creating systems that use LLMs.

Comments URL: https://news.ycombinator.com/item?id=48716340

Points: 1

# Comments: 1

If the expiration is for example one day, you might never see it.

To my knowledge, Protonmail does not even show information that the email has expiration. Nor can you access log of deletions.

This feature was used against me on a court trial.

- I coded myself a portfolio manager to manage all the projects that I have

- secrets management tool to avoid accidental leaks of tokens by AIs

- tool for automatic creation of training/product presentation videos for web apps

- sales training app

This particular use case is people working together to collect data in a workshop. 10 people don’t want to see somebody searching for the right place in a form, it interrupts the flow of the meeting. You need to capture the ideas raw, and then structure later. That is where question anout how unstructured data is captured in strucured format pops up.

It is a workflow I directly support in my tool, not a generic tool like yours.

I have a related need, to create some great product spec sheets.

Recently I have had trouble with Sentry. I have a site that has a lot of data coming in (2M page views per month) and Sentry starts being unusable for a solo developer. And on the other hand, I have several Django projects where I want to have common way to handle bugs.

I am feeling Sentry UI is too complex for my use cases, and on the other hand, I would like to automate the process as much as possible -- and the idea of automatic bug fixing is neat!

I am experimenting with Bugsink. Supporting Bugsink internally but build some tooling around it for automatic bug detection and fixing would actually be a sweet spot for me.

I was actually working on last weekend with something that has similarities. I am working on USM.tools, which allows specifying your services in structured way.

There is a need to specify some of the data in semi-structured way, and I am using markdown for that.

So there is this interesting relationship between unstructured, semi-structured and structured data, and markdown hits that middle ground.

Can I suggest you make some Jira etc. templates on your landing page clickable, so a visitor can grasp your idea more easily? For me it was not clear whether the specs are just plain markdown, or do you have some additional tagging there.