Blog
From the Gander team
On agentic engineering, product development and how to get the most from Gander
When the agent changes the plan halfway through
Suppose, for the sake of a concrete case, that you approved a plan yesterday. It said the agent would add rate limiting to the public API by wrapping the existing handlers, with limits read from config. Short, clear, easy to say yes to. Today you open the pull request and the handlers aren't wrapped at all. The agent moved the limits into a new middleware layer and changed how config loads at startup. Maybe that's a better design. But now you have two documents in front of you that disagree, and nothing that says when the plan changed or why.
The handoff note an agent leaves
An invented scene, just to keep it concrete. You open your laptop and there's a finished agent run waiting from last night. The diff is clean. It moves session handling out of a controller and into its own module, updates the call sites, and adds tests that pass. Then you notice the old cookie path is still there, untouched. Did the agent leave it on purpose? Did it miss it? Is it half done? The diff can't tell you. So you spend the next half hour reading code to rebuild what the agent already knew when it stopped.
Keep a decision log, not a status update
The board is green. Every card says done. Made-up case, to keep it concrete: last week the team picked polling over webhooks for a sync job, ran the work through an agent, and closed the ticket. Today a new agent session opens the same board, sees green, and starts drafting a webhook redesign because the codebase "looks unfinished" without one. Nobody left a note saying polling was a deliberate choice. Status said the work finished. It never said why that path won.
Would I know if it were wrong?
An engineer is one click from approving an agent-written plan. The case is made up, but the shape is familiar. They asked for retry logic on a payment webhook handler. What came back is tidy: exponential backoff, a max of five attempts, idempotency keys on every retry, and a short note about logging failed deliveries to a dead-letter table that already exists. Clean prose. Numbered steps. Nothing looks sloppy.
A spec is done when someone else can say what's out of scope
Here's a hypothetical, made up to show the moment. A lead writes a short spec for an agent: add email receipts when an order ships. The goals are clear. Send a receipt. Include the order number and the items. Use the existing mailer. Nothing in the list looks wrong. They hand it to the agent and move on.
Running a team where some members are agents
Here's a hypothetical, made up to show the moment. A small product team has started handing real work to agents. One drafts the weekly customer update. One writes first-pass plans for new endpoints. Another cleans up the changelog before each release. For a few weeks it feels like the team got bigger without anyone being hired.
"Looks good" is the most expensive comment
Here's a hypothetical, made up to show the moment. An agent writes a plan to add rate limiting to a public API. It's tidy: a token bucket per key, a new middleware, a config block, a rollout in three steps, and a section near the end about backfilling usage history from old logs so limits apply from day one. You read it on your phone between meetings. Nothing jumps out. You type "looks good" and move on.
"The agent wrote it" is not an owner
Here's a hypothetical, made up to show the moment. A team ships a migration guide for customers moving to a new API version. An agent drafted it from the changelog, a couple of people looked it over, and it went out on Tuesday. On Thursday a customer writes in. Step four tells them to drop a field that older clients still read. Support forwards the message to the team channel and asks a simple question: who owns this doc?
Teaching an agent what it doesn't know
Here's a hypothetical, made up to show the moment. An agent drafts release notes for a new sync feature. The draft is clear, well organized, and accurate about what changed. Near the end it says, "Sync is now twice as fast for large workspaces." It reads like the kind of thing release notes say. Nobody on the team measured that. Nobody knows where it came from. It's one sentence in an otherwise good draft, and it's the sentence that would have been quoted back at you.
The PRD is a working file, not a document
Here's an illustration, made up to show the shape of the problem. A spec for a new export feature says users can export up to a year of history. Two weeks into the build, someone on a call points out that a year of history times the biggest accounts is a very large file, and the team agrees to cap exports at ninety days for now. Everyone nods. The spec still says a year. A month later an agent picks up the follow-up work, reads the spec it was pointed at, and builds the settings screen with a one-year option. It did exactly what the document said.
The session that wrote it knows why
Here's a hypothetical, made up to show the problem. An agent writes a rollout plan for a config change. A reviewer reads it and leaves a good comment on step four: "Why are we flipping this for everyone at once? Can we start with one region?" Someone on the team sees the comment, copies the plan and the comment into a new chat, and types "just fix it." A fresh agent rewrites step four to roll out one region at a time. It reads well. It also brings back a staging step the first session had dropped an hour earlier, for a reason that never made it into the file.
Where the human checkpoint goes
Picture an agent that helps run a small internal tool. This is a hypothetical, an illustration I made up to make a point, not something that happened. One afternoon it is asked to tidy up stale records. It finds a batch that looks abandoned, deletes them, and posts a friendly summary to a shared channel. Nobody approved the deletion. Nobody approved the message either. Both were within what the agent had been allowed to do, because nobody had decided where the line was.
A brief an agent cannot misread
Here is a brief. It is an illustration I made up, not a real one, but you have probably written its cousin.
The bottleneck moved to review
A plan used to cost an afternoon. That filter is gone. The scarce step in agentic engineering moved to review.
One install for the author
So you are staring at another CLI and wondering if it is worth the tax.
Configurable Privacy
Out of the box, a first Gander share is visible to anyone with the link, with commenting limited to you and your team. Configurable Privacy means you get to change that default.
Any two is a feature
Live watch, Docs-style threads, and @agent back into the session. Miss one and you are sharing again.
Comments that survive the rewrite
The agent will rewrite the plan. Your comments should still be there.
The plan lives on your machine
The agent is rewriting plan.md on disk. The link is the review surface, not a second copy.
Your teammate shouldn't need your IDE
Reviewer needs a browser and a link, not your IDE, repo, or agent session.
Let the agent write the plan
Let the agent write the plan. Do not let it run alone: live review before execute.
Review before git
The agent is still writing. Send a link before you invent a PR just to get comments.
The reviewer is not in the IDE
Your lead is on a phone. They should not need Cursor, a clone, or a seat in your agent session.
Comments the agent can act on
Start with @agent and the session that owns the file can take the work. No Slack paste.
Watch the file, not the PR
Hosted watch is a live link for a file that is still changing. Local --watch is a different command.