coding posts - idmontie's Portfolio

"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = {
    a: "a",
    code: "code",
    img: "img",
    p: "p",
    pre: "pre",
    ...props.components
  };
  return _jsxs(_Fragment, {
    children: [_jsxs(_components.p, {
      children: ["I recently published a utility ", _jsx(_components.a, {
        href: "https://github.com/idmontie/human-agent-review-tool",
        children: "Human Agent Review Tool"
      }), " that helps keep track of the code I've actually reviewed while working with coding agents."]
    }), "\n", _jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2026-09-16-review-tool/repo.png",
        alt: "Review Tool Repo"
      })
    }), "\n", _jsx(_components.p, {
      children: "AI coding agents have made it possible to iterate on ideas and features extremely quickly. This is extremely helpful when building proofs of concept, experimenting with ideas, and creating internal scripts and utilities."
    }), "\n", _jsx(_components.p, {
      children: "But that workflow of working with a coding agent to produce code introduces a simple problem: which files have I actually reviewed?"
    }), "\n", _jsx(_components.p, {
      children: "When using Cursor, each agent workflow typically let's you review files. But this interface is typically all or nothings – once you commit and move onto the next workflow, that diff is gone."
    }), "\n", _jsx(_components.p, {
      children: "In a traditional workflow, a pull request provides a nice interface and check-in point for code review. When working locally with an agent, I don't necessarily create a PR for every single feature, nor do I want to for work that might be throwaway code."
    }), "\n", _jsx(_components.p, {
      children: "After several rounds of prompting, testing, and iterating, it can become suprisingly difficult to remember what code changes I have personally looked at."
    }), "\n", _jsx(_components.p, {
      children: "The Human Agent Review Tool gives a lightweight way to track that."
    }), "\n", _jsx(_components.p, {
      children: "After globally installing via"
    }), "\n", _jsx(_components.pre, {
      children: _jsx(_components.code, {
        className: "language-bash",
        children: "pnpm i -g review-tool\n"
      })
    }), "\n", _jsxs(_components.p, {
      children: ["you can run ", _jsx(_components.code, {
        children: "review-tool"
      }), " from a Git repository and it will open a local dashboard containing all the files in the project. Each file can be marked as Reviewed, Unreviewed, or Needs Changes."]
    }), "\n", _jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2026-09-16-review-tool/review-tool-dashboard.png",
        alt: "Review Tool Dashboard"
      })
    }), "\n", _jsx(_components.p, {
      children: "I can also attach notes to the files that need additional work, giving me a simple queue for the next iteration with the coding agent."
    }), "\n", _jsx(_components.p, {
      children: "The tool tracks the review state separately from the source code, and if a previously reviewed file changes, that review state becomes stale so that it can be reviewed again. It also supports ignoring generated files or other files that aren't useful to inspect manually."
    }), "\n", _jsx(_components.p, {
      children: "The goal isn't to replace pull requests, or any traditional code review. Rather it is meant to help with the local development workflow that happens before a traditional code review: allowing a human and agent to rapidly build together on a local codebase."
    }), "\n", _jsx(_components.p, {
      children: "As coding agents become capable of producing larger features and code changes, I think tools that help developers maintain oversight will become increasingly important."
    }), "\n", _jsxs(_components.p, {
      children: ["The project is available on Github: ", _jsx(_components.a, {
        href: "https://github.com/idmontie/human-agent-review-tool",
        children: "https://github.com/idmontie/human-agent-review-tool"
      }), "."]
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, {
    ...props,
    children: _jsx(_createMdxContent, {
      ...props
    })
  }) : _createMdxContent(props);
}
return {
  default: MDXContent
};


I recently published a utility <a href="https://github.com/idmontie/human-agent-review-tool">Human Agent Review Tool</a> that helps keep track of the code I&#x27;ve actually reviewed while working with coding agents.
<img alt="Review Tool Repo" src="/media/2026-09-16-review-tool/repo.png" style="max-height:500px;margin:auto;text-align:center"/>
AI coding agents have made it possible to iterate on ideas and features extremely quickly. This is extremely helpful when building proofs of concept, experimenting with ideas, and creating internal scripts and utilities.
But that workflow of working with a coding agent to produce code introduces a simple problem: which files have I actually reviewed?
When using Cursor, each agent workflow typically let&#x27;s you review files. But this interface is typically all or nothings – once you commit and move onto the next workflow, that diff is gone.
In a traditional workflow, a pull request provides a nice interface and check-in point for code review. When working locally with an agent, I don&#x27;t necessarily create a PR for every single feature, nor do I want to for work that might be throwaway code.
After several rounds of prompting, testing, and iterating, it can become suprisingly difficult to remember what code changes I have personally looked at.
The Human Agent Review Tool gives a lightweight way to track that.
After globally installing via
<div class="overflow-auto rounded-2xl bg-[#0e005d6d] p-4 font-mono text-sm dark:bg-[#0e005d6d] dark:text-gray-100"><pre><code class="language-bash">pnpm i -g review-tool
</code></pre></div>
you can run <code>review-tool</code> from a Git repository and it will open a local dashboard containing all the files in the project. Each file can be marked as Reviewed, Unreviewed, or Needs Changes.
<img alt="Review Tool Dashboard" src="/media/2026-09-16-review-tool/review-tool-dashboard.png" style="max-height:500px;margin:auto;text-align:center"/>
I can also attach notes to the files that need additional work, giving me a simple queue for the next iteration with the coding agent.
The tool tracks the review state separately from the source code, and if a previously reviewed file changes, that review state becomes stale so that it can be reviewed again. It also supports ignoring generated files or other files that aren&#x27;t useful to inspect manually.
The goal isn&#x27;t to replace pull requests, or any traditional code review. Rather it is meant to help with the local development workflow that happens before a traditional code review: allowing a human and agent to rapidly build together on a local codebase.
As coding agents become capable of producing larger features and code changes, I think tools that help developers maintain oversight will become increasingly important.
The project is available on Github: <a href="https://github.com/idmontie/human-agent-review-tool">https://github.com/idmontie/human-agent-review-tool</a>.


I recently published a utility [Human Agent Review Tool](https://github.com/idmontie/human-agent-review-tool) that helps keep track of the code I've actually reviewed while working with coding agents.

![Review Tool Repo](/media/2026-09-16-review-tool/repo.png)

AI coding agents have made it possible to iterate on ideas and features extremely quickly. This is extremely helpful when building proofs of concept, experimenting with ideas, and creating internal scripts and utilities.

But that workflow of working with a coding agent to produce code introduces a simple problem: which files have I actually reviewed?

When using Cursor, each agent workflow typically let's you review files. But this interface is typically all or nothings – once you commit and move onto the next workflow, that diff is gone.

In a traditional workflow, a pull request provides a nice interface and check-in point for code review. When working locally with an agent, I don't necessarily create a PR for every single feature, nor do I want to for work that might be throwaway code.

After several rounds of prompting, testing, and iterating, it can become suprisingly difficult to remember what code changes I have personally looked at.

The Human Agent Review Tool gives a lightweight way to track that.

After globally installing via

```bash
pnpm i -g review-tool
```

you can run `review-tool` from a Git repository and it will open a local dashboard containing all the files in the project. Each file can be marked as Reviewed, Unreviewed, or Needs Changes.

![Review Tool Dashboard](/media/2026-09-16-review-tool/review-tool-dashboard.png)

I can also attach notes to the files that need additional work, giving me a simple queue for the next iteration with the coding agent.

The tool tracks the review state separately from the source code, and if a previously reviewed file changes, that review state becomes stale so that it can be reviewed again. It also supports ignoring generated files or other files that aren't useful to inspect manually.

The goal isn't to replace pull requests, or any traditional code review. Rather it is meant to help with the local development workflow that happens before a traditional code review: allowing a human and agent to rapidly build together on a local codebase.

As coding agents become capable of producing larger features and code changes, I think tools that help developers maintain oversight will become increasingly important.

The project is available on Github: https://github.com/idmontie/human-agent-review-tool.


Keeping Humans in the Loop for Agent-Written Code