Translating pseudo-code to real code is almost table stakes for any decent LLM at this point. But getting architectural feedback in the same abstraction layer you think in, that's a different thing entirely.
I've noticed something similar when working with Claude Code. The quality of the back-and-forth improves significantly when you stay at the intention level rather than jumping straight to implementation. Once you're in the weeds of actual syntax, the conversation tends to collapse into micro-corrections. Staying pseudo keeps the design space open longer.
One thing I'd be curious about: how does it handle the translation when your pseudo-code has ambiguous control flow? That's usually where I hit the wall. The semantic intent is clear to me but there are three or four valid ways to implement it and the model just picks one without flagging the decision.
I agree - in the end we have some fuzzy turing machine when writing in pseudo code. I think it is inherently hard to get this right. I also think that these decisions about control flow etc should stay with the developer given I find it very rewarding and LLMs are not very good at it yet (even though they have promised us the improvements for the past 5 years lol).
> The LLM will suggest changes (design, architecture, functionality, ...) to your code, but will roughly use your pseudo code style.
So it will change your architecture, but keep your line-by-line logic? Is this like a self-driving car that takes you to the wrong destination, but accurately follows traffic laws on the way?
Give me the opposite - something that builds exactly what I designed, but has the freedom to get there in better ways than I suggest.
Great point on the flow state with pseudo code. The gap I keep running into is what comes after – once the translated code ships to production, knowing quickly whether it actually behaves as intended is still mostly manual. Curious if others have thoughts on that part of the loop.
feedback: your psuedo code example is just product requirements and not actual psuedo code. and I think if you wrote psuedo code it would just work as is without a skill
Translating pseudo-code to real code is almost table stakes for any decent LLM at this point. But getting architectural feedback in the same abstraction layer you think in, that's a different thing entirely. I've noticed something similar when working with Claude Code. The quality of the back-and-forth improves significantly when you stay at the intention level rather than jumping straight to implementation. Once you're in the weeds of actual syntax, the conversation tends to collapse into micro-corrections. Staying pseudo keeps the design space open longer. One thing I'd be curious about: how does it handle the translation when your pseudo-code has ambiguous control flow? That's usually where I hit the wall. The semantic intent is clear to me but there are three or four valid ways to implement it and the model just picks one without flagging the decision.
I agree - in the end we have some fuzzy turing machine when writing in pseudo code. I think it is inherently hard to get this right. I also think that these decisions about control flow etc should stay with the developer given I find it very rewarding and LLMs are not very good at it yet (even though they have promised us the improvements for the past 5 years lol).
> The LLM will suggest changes (design, architecture, functionality, ...) to your code, but will roughly use your pseudo code style.
So it will change your architecture, but keep your line-by-line logic? Is this like a self-driving car that takes you to the wrong destination, but accurately follows traffic laws on the way?
Give me the opposite - something that builds exactly what I designed, but has the freedom to get there in better ways than I suggest.
It won't keep the logic. It is encouraged to change the line-by-line as well as the overall logic!
LLMs work perfectly well without a pseudocode skill. It natively understands pseudocode just as well as it understands Indonesian.
That's not the point of the skill.
Great point on the flow state with pseudo code. The gap I keep running into is what comes after – once the translated code ships to production, knowing quickly whether it actually behaves as intended is still mostly manual. Curious if others have thoughts on that part of the loop.
Why would that be any more manual than it has been before? You still write or have Claude to write unit and integration tests thst you review
I feel like that this is fundamentally impossible to solve for. Approximately the effort = planning + checking correctness seems to be constant.
Btw, I got inspired by this: https://www.williamjbowman.com/blog/2026/03/05/against-vibes...
Really useful read!
feedback: your psuedo code example is just product requirements and not actual psuedo code. and I think if you wrote psuedo code it would just work as is without a skill
True (will fix) - but then still, Claude will still not change my pseudo code, but directly translate. I liked that part particularly.
https://github.com/HalfEmptyDrum/Pseudo-Code-Flow
the link again