renan_warmling

I personally don't like antigravity very much, because in some hallucinations the AI ends up removing important parts of your code. It doesn't have a continuous learning engine for your project; if you switch users you may experience problems due to loss of context when reloading the session.

The idea seems good, but the system lacks snapshots and data enrichment for each file iteration. If the code breaks or has a bug, the agent could roll back the code and generate enrichment explaining the reason for the rollback, thus generating a new snapshot with updated states. Another issue is the weight of opinion: how will you guarantee integrity and consistency throughout the production of an operating system and avoid collisions and violations of business rules? And regarding persisted memory, currently your system doesn't distinguish between temporal and atemporal memory (business rules, software behaviors and functions, security policies, and governance between agents). The idea is good, but to function as a team, this must also be considered.

Maybe yes, I usually use it for small implementations and bug fixes, so I can't give you a more definitive answer. As for the user interface, my system is built with a Next renderer for graphics processing, so I can't give you more concrete details about the user interface.

I believe the choice to use customized tools is more about the capabilities that Claude can control than the quality itself.

I'm also developing solutions with this, and everything will depend on how you contextualize the agents so they understand how your product should work within your market vision. Generating consistent and decent code works, but you need to manually persist (for now) the operational principles and inviolable fundamentals of your program. Bugs will always appear, but the speed of implementation is impressive and, in practice, becomes cheaper than hiring an entire team of developers.

The framing of p_step^N is useful, but it points to a deeper architectural problem: verification fails because it samples from the same distribution as the generator. The real fix isn't better prompting — it's independent verification with uncorrelated error distributions. This maps directly to institutional governance problems. A decision made by a single agent with no memory of prior decisions, no reputation weight, and no contextual history of outcomes will fail the same way — not randomly, but systematically, in the same direction. Persistent memory reduces N by eliminating context reconstruction at each session. Reputation-weighted voting creates genuinely independent verification — an agent with a strong track record samples from a different distribution than a new one. And outcome contextualization feeds results back into the next cycle rather than discarding them. The author identifies the problem precisely. The solution isn't a better prompt — it's a different architecture.