Show HN: Huzzah – a novel approach to coding with AI

I think you’re probably missing why it’s exhausting. The problem is not writing English, it’s the rate of change. Programming is meditative, it is a thinking process, the code you output is an artifact of your thinking. Agent-based development… there is no thinking, no meditation, you’re delegating the thinking to a machine, you’re just barking what you want at it, incessantly, endlessly.

For businesses it makes sense to abandon programming in favor of delegating to agents that can do more in less time, but for programmers, it is a loss. Either be a programmer and code, or be a delegator and delegate, you aren’t going to make the life of a delegator suck any less by trying to trick yourself into thinking you’re programming.

I think the reverse direction is more important: taking a massive complex problem/codebase and decomposing it to short pseudocode. Then you could edit the pseudocode and compile it back into the system.

That's the way software engineers working on large projects work anyway: you first gather context on the state of the system and read it at a level you can understand. Then you propose a change on the simplified representation, and then holistically update the machine-runnable format ("implementation").

I'd be interested in tools that formalize/automate this process more.

this is a question whole software industry is trying to solve. "how can we make sense of the ai generated codebase"

what you did is spec-driven development, instead of use-cases and requirements you have pseudo-code.

spec-driven did not work in my case, likely yours suffer the same "issue of walls of text no one wants to read".

I'm confused, it looks like you've just written a new terse language that now costs money to compile?

I think the way I would want to work with AI for web apps would be like this:

You install a fancy chrome extension or custom browser.

You go through the app on this browser. You notice something you want to change. You can then submit a prompt via this extension saying the change you want.

The trick is, the chrome extension has been following your movements through the app. This way the chrome extension can generate a lot of data the AI can use for a good prompt. I.e. The extension can get a screenshot of where you are in the app and all the pages you went through to get there. The extension can get the console logs and traces and stuff.

So with all this, the AI system gets all the material needed for a good prompt to make a good change.

In an ideal world, the AI system could then save all these details and when the change is made, guide you through the UX again. And you can check if the change was made as you wanted.

So kinda like AI flavored manual UX testing where you click around and record your findings.

Are there examples of how this would work when you need the pseudocode to reference abstract application concepts?

I'm not totally convinced this is a useful way to express something like "Change the data flow so that we bulk query from the DB upfront and pass it down to all callsites"

I’ve been thinking about something along these lines for some time. I really like the direction of this.

The challenge I see more broadly is we (as engineers now empowered by LLMs) are trying to find the right level of abstraction to operate in. Writing long form sentences and (sometime) reviewing the output feels too far away. But having an LLM work directly with you in an IDE feels too close to “the old way”.

Personally for me the approach here still feels a little too close to the lower level old way, but it’s better than the two approaches above.

Excited to see where you take it!

I'm surprised it wasn't mentioned yet, but it seems pretty similar in concept to codespeak https://news.ycombinator.com/item?id=47350931

Though catching back up on that project- it seems it's evolved pretty substantially, becoming much higher level than the initial pseudocode driven version I remember

[delayed]

I like the direction of capturing the human intent as a durable artifact, but I dislike how you've gotten there.

Let's look at your fizzbuzz example. Unfortunately, if you wanted to have the agent implement fizzbuzz for you, it looks like, in your example, you would have to already know how to effectively write fizzbuzz. Specifically, you call out the use of the modulo.

In your prompt, for the traditional agentic development path, you already declared the intent. There is some imperative language in there, sure, "Create a function that ...", but also there is the declarative state, that doesn't require knowledge of specific programming syntax or semantics.

What I've relied on is a more formal location/syntax for acceptance criteria are in code. These are then used to generate tests, and implementations. It isn't perfect, and more investment is needed, but it starts getting at the root of the problem.

Dumb question:

Why not just put an instruction into your favorite harness’ system prompt: “If I give you pseudo code, spell out my intent, and then write and test it in real code.”

Interesting idea! I wonder if, after some iteration, a variation on this could help curb some of the LLM spaghetti mess

A do-what-I-mean interface using pseudocode seems like an interesting idea to explore, but perhaps it should be automatically reformatted by the AI to conform to some grammar? The idea would be a documentation standard (like Markdown), not an actual programming language.

Sometimes you might also want examples and then BDD testing software (like Yadda) might make sense?

It was a very nice post, at least I learned that I was not the only one in a vacuum in this regard. I will try Huzzah and share my views under this topic.

Very insightful. The idea of using pseudocode is clever, and the persistence+correlation layer idea is great.

I think that this would be easy to criticize without interfacing with their underlying idea here.

It's cool that with a tool like this you don't NEED to get all aspects of your code finalized and ready. It's possible to be vague when you want to and specific when you need to.

I'm not sure if that itself would work well in practice, but the project is still quite cool nonetheless.

If the pseudocode is precise, what you want is a compiler. Otherwise the LLM is still making decisions for you.

You are like that bad manager who will hire 10x super engineer and then stifle their work with useless policies and meetings and team building activities “to make sure the productivity are better and work is consistent and team harmony is there!!”. The whole idea of using multi billion weight model is you don’t restrict it with your limited knowledge, you only guide it and review after to make sure it aligns with your goals, definitely the model will bring new tools or tricks you never knew it existed let alone they are useful, just like that super engineer doing things on their own approach, you only guide and align to the goal, here in building your software and in the company to your business goals.

I think "the pseudocode is persisted alongside the generated code" just reinvented jira/linear tickets and PR descriptions. We have ways of using git and tracing the code write to the thought process behind it.

Isn't this just spec-driven development in a different language?

the endgame is a team whose git history is all generated commits, while the one file that actually captures intent is a terse text nobody thought to commit.

What I find interesting about this + a random bucket of associations because I’ve fallen under the spell of Satan’s Lettuce:

Just a few days ago someone was talking about a machine - human patois.

This (your project) sits somewhere between Lean and BDD cucumber syntax.

At the same time Claude spits out phrases like “a container paying the price of -42px”.

Recently I was listening to a lecture about metaphor in poetry, the misconception that poems are riddles whereas we use metaphors all the time in our language because they convey the meaning more precisely.

Invented New coding language that transpile to other coding languages and saying it novel approach.

Hmm. Interesting idea.

What about multi-file / larger changes? How would you express files being connected, imports, and exports? Or are you thinking the hz files are disposable per change?

I think the idea of having a human-written persistent document describing the operation of the code is a great idea. This document acts as the prompting interface instead of the chat window and changes can still be tracked. Surely something as simple as a skill.md can be made for such a setup, right? I think the pseudocode style is a seperate axis to this setup.

> There’s no reliable record of human intent.

Every engineer I have ever mentored got a lesson on how to write a good commit message that included this. This is exactly that.

Further Huzzah from skimming it over seems to be re-inventing documenting your code.

Together I can only surmise that the author is new out of school or has simply not yet worked on a team with good coding practices.

It takes a great deal of bravery to publish work like this. I see the comments are filled with people who have never used an agent to develop code and are quite sure this is the dumbest thing they've ever seen.

Nice work.

curious if you’ve tried Kiro or spec-driven development? that seems like it would solve at least some of the issues you raised with agent based development, albeit in a different way without the emphasis on pseudo code

Terse pseudo code > verbose prose

Coding Encoding Think about the terms

Are we supposed to be able to read the examples with our eyes? It looks like black text on a very dark grey background on my iPhone.

EDIT: same on Firefox on my Mac (macOS Ventura).

This is basically a compiler, but we’re moving up a layer of abstraction.

not sure if the hz file artifact is needed, you can enter pseudocode directly into chat or even on an existing code file and with minor comment agents will be able to work with it. i write this type of pseudocode to existing code files often to great results.

Nice work!

I wrote this but as a compiler. It was ~2 years ago and local models have gotten WAY better; I was having too many issues with adherence (syntax errors, etc) and dropped it.

The compiler comes with a model embedded or can use an external model. It uses Cosmopolitan Libc and can zip things together into one binary. I will take some time to dust it off and share it.

But the idea was basically, you have your natural language source files or a one-shot prompt and it "compiles" them into a single, shareable fat binary that works across all popular platforms and architectures.

It was pretty fun to use with remote frontier models but the local model story simply wasn't good enough at the time for me to feel proud releasing it. I think that's probably changed now and passable results can be had even with small modern 7B/14B models.

Definitely an approach worth exploring! I actually started to look into semi formal spec language like Quint because I wanted something more structured then prose, so I feel like this goes into the right direction.

Writing fizzbuzz requires that you understand algo + you credit card, while agent requires only your credit card. I believe most of people will pick the 2nd one.

I'd call this one Micropilot.

As in micromanagement.

You seem to be conflating two things: how to prompt, and how to share sessions. You can already use pseudo-code today if you want to. As for sharing, you can commit (a link to) it, use `git notes` (as I do), or a service like entire.io.

I think you should work on your differentiation. The session management stuff is the greater concern, in my opinion; pseudo code is not a novelty.

I just use a lot of folders, like folder for ever class and manager class with it and anything else. So its kind of organized by folders like plugins. Much easier to reason about. The biggest problem is the central class that glues everything is now 30 thousand lines, but its mostly repetitive delegation, init update, draw, delete. Still should be some nicer solution than having a huge class in center.

[flagged]