Skip to content
A Rapid Impact Labs product

Notes on the page Changes in the repository

You already run a coding agent. What you do not have is a way to get a client's note out of their head and into that agent without someone retyping it. PinPoint anchors the note to the exact spot on the live page, hands the agent a structured task with those coordinates attached, and re-shoots that same spot so you can see whether the change landed.

Early access, by request. Tell us what you build and who reviews it; one paragraph is enough. Included at no extra cost while you are on a Fractional CTO retainer.

Schematic. A pin and a spoken note on the left become a structured task and a reviewable diff on the right.
The gap

Feedback stops at a comment

A client sends eleven notes about one page. Someone opens the site in one window and the agent in another, and types eleven prompts describing things the client was already pointing at.

Call it the retype. It is the one step where the information gets worse: the client pointed at a thing, and what reaches the agent is a sentence about that thing, written by a third person guessing at what the first one meant. Nobody is doing this badly. The step itself is lossy.

Annotation tools promise they will never touch your code, and that promise is exactly why they cannot close the loop. Coding agents assume a technical operator is already sitting there typing. Between them is a gap nobody owns: a non-technical client's visual intent on a live site, turned into a change in the code that produces it.

What gets lost

Coordinates, first. A note that said “this, here” becomes a note that says “the hero image”, and the agent now has to guess which one.

What it costs

Not the code. That edit takes an agent you already pay for about two minutes. The cost is the person standing between the two windows.

How it works

Pin, dispatch, verify

Four steps from a client's note to a reviewed change, in one sitting. The reviewer never installs anything and never sees a terminal. You keep the repository, the agent, and the decision to ship.

  1. 01 · PIN

    Point at the live page

    Paste a URL and the real site renders inside the board, with its other pages pulled from the sitemap where the site exposes them. Click anywhere to drop a pin; the click is captured with the scroll position it happened at, so the pin stays on the thing it pointed at. Then type, talk, or draw on a screenshot of that spot.

  2. 02 · DISPATCH

    The pin becomes a task

    Each pin becomes one task in a single tasks.md file: page, coordinates as percentages, the thread, the transcript, the annotated screenshot. A test locks the format so it cannot drift. Hand the file to whichever agent you use, or dispatch it from inside the app to one bound to your repository. Open pins from every board queue up in one list, so a week of notes is not eight tabs.

  3. 03 · VERIFY

    Check the same spot, after

    The pin kept its coordinates, so that exact region is re-shot when the run finishes and the before sits against the after. Approve and the pin resolves; reopen and it returns to the queue with your reason in its thread. The run's exact changes stay in the owner-only What changed view, since anyone on the share link can read that thread. A clean exit means a process ended, not that the change is correct, so a person still decides.

  4. 04 · SHIP

    Read the patch, then push

    The git diff sits there to read before anything leaves your machine. Push when you are satisfied. Undo the last push when you are not: one button that writes a revert commit rather than starting a rescue operation. The commit stages the whole working tree, so keep it clean before a run.

The handoff

The part that is not a marketing verb

Every other feedback tool ends at a comment a human has to read. PinPoint ends at a file an agent can parse without ceremony. The format below is the real one, emitted by the same serializer the product ships, with invented content in it: status in brackets so an agent can grep for open work, coordinates so it knows where on the page you meant, voice notes tagged as transcripts, screenshots as relative paths in the same zip.

One file plus the images. Copy it into the agent you already use, or let the app dispatch it.

tasks.md
# PinPoint Tasks — Example Dental

> Source: https://example.com
> Exported: 2026-08-04T09:12:44.180Z
> Board ID: brd_8fj2
> Total: 3 tasks (2 open, 0 in-progress, 1 resolved)

---

## Task 1 — Hero headline runs to three lines [open]

**Pin:** pin_a71c
**URL:** https://example.com
**Page:** /
**Coordinates:** x=42%, y=18% (viewport 1440×900)
**Assignee:** Reiden
**Created:** 2026-08-04T08:55:02.001Z

**Change request:** Cut the hero headline to eight words or fewer and keep the booking button on the first screen.
**Category:** copy
**Section:** hero

### Notes
- (voice, transcribed · Client) "The headline is doing too much. It pushes the booking button off the phone."
- (text · Reiden) Match the brevity of the services page.

### Screenshot
`./screenshots/pin_a71c.png`
_Annotated — the drawn markup (circles, arrows, text) on this image is part of the instruction._

Example output. The board, the client, and the notes are invented.

What is real

What it does today, stated plainly

We would rather tell you where the edges are than have you find them during a client call.

PinPoint runs as a single-operator tool on your own machine. That is how we use it and how you would start. The half that turns it into a hosted, multi-account product is being built in order, deliberately, because the missing parts are the ones that are dangerous to get wrong.

Not there yet

The store

Your browser is the database. One machine, no sync, and a ceiling that drops the whole save when you cross it rather than warning you. A board lives on the machine that made it.

Client links

Share links carry a scope, an expiry, and a revoke, but the board they point at lives in one browser profile, so a link only opens on the machine that made it. Client review today happens on your screen or on a call.

The agent

File editing needs an agent on the same machine as the repository, and the API providers in the picker are chat only. A hosted runner that clones a connected repo and opens a pull request is the next large build, not a shipped feature.

Pin drift

Pins are anchored to coordinates, not to the DOM. When an agent changes the length of the text under one, the marker can end up beside the thing it pointed at.

Accounts

No seats, no orgs, no isolation between two customers on one instance. Which is why we set them up one at a time.

Who it is for

Built for the shop that already runs an agent

PinPoint assumes two roles, because that is the shape the work already has. Not seats, not tiers, not a project manager in the middle.

The operator

You hold the technical side

You point a board at the folder your site lives in, pick the agent, read the diff, approve every change. Your code stays on your machine and reaches whichever model provider you chose, never us.

The reviewer

They look and they talk

A page, a pin, a sentence said out loud. No account, no install, no explanation of what a branch is. Today that happens beside you or on a call; it becomes a link they open themselves when the backend lands.

Probably not for you if

  • You want a comment tool that files tickets and never touches code. Good ones exist and they are cheaper.
  • You need seats, roles, and audit trails today. None of it exists yet.
  • You want a hosted agent that clones a repo you never expose to your own machine. Next build, not this one.
The dogfood rule

Nothing is offered here that we are not already running on our own work. Every edge listed on this page is one we hit first, on our own client sites, before anyone else could.

Questions

The things you would ask on the call

Is this live, or a waiting list?

Live, and we use it. What is not finished is the hosted half: a board lives on the machine that created it, and the file-editing agent runs there too. Access goes through a conversation because that difference matters and a form cannot explain it.

Do you need access to my repository?

No. The agent runs on your computer, with your credentials, against your disk, so your code never passes through anything of ours. A hosted runner with a scoped, revocable install is planned rather than built, and the local path stays either way.

Does it work on a site I do not host?

Marketing sites, docs, and landing pages render well. Heavy single-page apps break past the first view, and a page behind a login needs a pasted session cookie that does not survive a restart. When a page will not render, drop a full-page screenshot and pin that instead.

What happens to my client's data?

Everything stays in the deployment you are running, which today is your own browser profile. Two things to know before a client call. First, the board is saved as a single blob, so once it crosses the browser's storage ceiling the save fails silently and anything added since the last good save is gone on reload; screenshots are what push a board over. Export the zip before a long session. Second, any browser with a built-in speech API uses it, and it wins automatically: Chrome and Edge and Safari all ship the audio to their own vendor. Firefox has none, so a Firefox reviewer routes through whatever transcription endpoint you configured. If audio must not leave your infrastructure, that is the combination to use.

Does my client need an account?

There are no accounts yet. Share links exist with a read or comment scope, an expiry, and a revoke, but the board they point at lives in one browser profile, so the link only opens on the machine that made it. Real client access arrives with the durable backend, which is written and not deployed.

What does it cost?

Nothing extra on a Fractional CTO retainer, where PinPoint is included. No pricing table is published because standalone pricing does not exist yet, and we would rather publish nothing than a number we already intend to change.

Getting access

Bring a site you are tired of describing in words

One sentence about what you build, one about who reviews it. If it fits, we set the first board up with you on a real client site: one round of notes, one agent run against your repository. If it does not fit, we say so on the call rather than three weeks into a trial.

01

Ask

What you build and who reviews it. A paragraph is plenty.

02

Twenty minutes

We walk your actual workflow. No pitch attached.

03

One real board

Set up with you, on a site you already maintain.

We take a few at a time so each one gets a real setup. If that sounds slow, it is.