margolis20

I think with the velocity of AI generated code, that's not even an option. There's no way code reviews can scale. We will need better tools for AI reviews, but also a direction that I think will become critical - knowing how to drive human attention where it is really needed. This seems to me one of the major parts that are missing today. We should know when a review is critical and when we can skip it.

Some more details about how this is structured:

Minimap is a portable package, which includes an agent skill, examples of feature and roadmap files, and a small node server for the UI. You point your agent to the skill, and just start the server in your project.

The file structure is quite simple: - board.md owns groups and item order - scope.md owns the current-focus narrative - features/.md owns committed or active work - ideas/.md owns uncommitted or parked work

The UI provides some views over these files. A regular list view, and also a column (kanban-like) view for easier planning. It allows viewing and also editing the features and the board.

I still do most of the planning work in conversations with the agent, but I find it very useful to be able to have this clear visualization of the features we produce.

Hi HN! I built BEAR as an experiment (which might actually be useful) around a problem I’ve been thinking about recently.

When agents can generate large amounts of code very quickly, many important changes become structural rather than purely implementation. New dependencies appear, boundaries widen, or components gain access to resources they previously couldn’t reach.

These are architectural changes, but they often get lost in normal diffs, especially when an agent can introduce many edits in the same PR.

BEAR explores one way to make those changes explicit. The idea is that an agent first describes the system as a set of architectural blocks in a small IR, and then works within those boundaries while evolving the implementation.

From that representation, BEAR generates deterministic checks, and CI can surface when a pull request expands the authority of a component instead of letting that change hide inside ordinary code edits.

Still very much an experiment, but curious what people think.

The Microdot framework for .NET helps you to create scalable and reliable microservices based on Orleans Actors, allowing you to focus on writing code that defines the logic of your service without the need to tackle the myriad of challenges of developing a distributed system.