plannotator

Inspired by Linear's guided reviews feature, this is an open source alternative: https://github.com/backnotprop/plannotator video demo: https://plannotator.ai/assets/guided-review-demo.mp4

Plannotator Inbox is an optional runtime using the best of plannotator annotation capabilities. While all your agents work they constantly bombard you with decisions that need to be made. Those decisions get lost over time, Claude might hit you with "I need your 2 answers to X and Y" which was asked 2 days ago. Think about all the remote pi durables to come basically... how can we surface all the important stuff we need to review... The chat ui thread, imo, is becoming outdated very fast. We need a new way to interface with agents and surface the things that matter in an intuitive way. Plannotator Inbox is a stab at that. part of the free/open source capability at: https://github.com/backnotprop/plannotator Also feel free to show your love or hate on the x announcement: https://x.com/plannotator/status/2108589088139886769?s=20

This is an agent skill that creates a portable code review file (HTML) for change sets and diffs. https://github.com/plannotator/guides/blob/main/skills/plann... It uses a baked in CDN that I host. Otherwise the size of the file would be pretty big. The diffs are by diffs.com. You can also create a share link with the hosted service, which I encrypt client-side and only decrypts through the link you share. The sharing service is also open source and self-hostable and open-source at https://github.com/backnotprop/plannotator Examples: https://guides.show/g/gs0M7zgI_zYeuqtLG4j5vQ#key=awkuPrNypYr... https://guides.show/g/Q-ECuRlzn6I2U41wmnyVmA#key=bA52euqWQyp...

> On (2), I do find myself consuming agents' gigantic text responses, writing 8-bullet-point responses to guide them, then iterating that way. It's pretty exhausting. I could see inline comments providing much better ergonomics. For your 2 plannotator [1] has a nice way to annotate agent messages or documents and its integrated into the agent chat (codex app also adopted the pattern) [1] https://github.com/backnotprop/plannotator

https://github.com/backnotprop/plannotator is still very useful for annotating html prototypes and markdown plans (as well as terminal agent messages). Was glad to see codex team pick up the feature requests in the Codex App. About to release a fun paid version. All contributors get lifetime free access. Better running agents run longer, they need better plans. (is my bet)

> The problem is defining what quality means, and providing a way for agents to optimize the harness using that lever. I've built and my team uses plannotator [1] for specs and code review. It stores all human annotated feedback, which we compile from time-to-time and iterate on coding standard skills for automated review (that seems to get better with the more feedback we provide). You could write a script that does the same for your PR review comments, which it sounds like you maybe do with a bit more structure. [1] https://github.com/backnotprop/plannotator

Plannotator opens a local diff viewer (git, jj, p4). You annotate lines, tokens, or comment on files, and when you're done they feed straight into your agent session; creating an automated feedback loop. It works on local diffs, commits, branches, worktrees, and GitHub/GitLab PRs. The PR view lets you annotate the descriptions and comments while also being able to filter bot comments. The core tool enables focused manual review, the optional AI layer: - Ask AI: Ask questions directly inline - Guided Reviews: Have an agent reorganize a large diff into semantic overview sorted by importance (inspired by linear) - Review Agents: Run review agents whose findings land as inline annotations. Review jobs can be your own skills that plannotator links to locally. There's also a local API, your agents can POST findings or other markers/insig

https://xcancel.com/plannotator/status/2073845811847512372?s... https://github.com/backnotprop/plannotator Plannotator Code Review works for any local or PR changes, jj, and p4. You can conduct a code review on your own or integrate it with your agents and submit feedbacks to create an automated iteration loop. Guided reviews works just like linear, except it also summarizes all file changes for you. The most important code changes are surfaced to the top, provided with a semantic overview & grouped diffs. It does not need to rely on advanced model intelligence or high reasoning efforts. Open source models work great at this task! Providers enabled include Claude Code, Codex, OpenCode, Pi, Cursor, and Copilot.

integrated agent review surfaces with https://github.com/backnotprop/plannotator HTML/artifact canvases have a lot of potential https://x.com/backnotprop/status/2064951065439834378?s=20 https://x.com/backnotprop/status/2065436433985474726?s=20 https://github.com/plannotator/effective-html Shared context workspaces are important https://plannotator.ai/workspaces/ https://github.com/plannotator/tot

I started this in January as a hook for Claude Code's plan mode: when it finished planning, instead of approving a wall of text in the terminal, the plan opens in your browser and you could mark it up like a document. Your annotations go back into the agent session. It grew from there. There's now PR-style code review (git, jj, p4, GitHub/GitLab PRs) and annotation for markdown, URLs, and folders. Agents produce a lot of HTML now, so Plannotator renders those artifacts and lets you annotate them too. Nine harnesses are supported: Claude Code, Codex, Copilot CLI, Gemini, OpenCode, Kiro, Droid, Amp, and Pi. Over 100 contributors. Nothing leaves your machine unless you share... which is E2E encrypted: eg. the plan is encrypted in the browser, the server stores ciphertext, and the key lives in the URL fragment. As agents get better, the bottl

> If I had to roll out such a development process today, I’d make a standardized Markdown specification the new unit of knowledge for the software project. Product owners and engineers could initially collaborate on this spec and on test cases to enforce business rules. Those should be checked into the project repositories along with the implementing code. There would need to be automated pull-request checks verifying not only that tests pass but that code conforms to the spec. This specification, and not the code that materializes it, is what the team would need to understand, review, and be held accountable for. The constant urge I have today is for some sort of spec or simpler facts to be continuously verified at any point in the development process; Something agents would need to be aware of. I agree with the blog and think it's going

I’ve done a lot of exploration here. Visual explainers certainly come in hand. You need to have both the extra time and cost of tokens accounted for when you ask for these. As well as maintainability - you lose things like vcs/diffs over plans that are much more readable as markdown. The more interactivity on the surface, the better. Esp if they create feedback loops with the agent. Simple annotations to start. Markdown still goes a long way. I’ve effectively been enriching plan rendering in Plannotator. Now supporting GFM, custom svgs, etc. https://github.com/backnotprop/plannotator For fun, I also enabled annotations on top of these type of svgs, see here https://x.com/plannotator/status/2052851731998941380?s=46

It never worked well for me. The only thing I really needed outside of the harnesses was a better plan review surface. https://github.com/backnotprop/plannotator