Skip to content

Build the right thing the first time

Grove gives product decisions what your code already has: one home, checks before anything’s built, and a read of what shipped against what you decided.

  • Product StrategyReach approvers wherever they are
  • Sam in sales · ClaudeThe CFO needs to see what she’s paying for
  • Priya’s coding agentWhat should a second tap show?
  • GitHub · #88 mergedApprove links in the email
P-240 Approve from emailProject
  • PlanChecks complete
  • Threads4 resolved
  • Outcomes1 of 3 ready
  • Delivery#88 merged

Code has GitHub. Product decisions have Grove.

Code lives in one repository. Grove gives product decisions the same shape, down to each project’s outcomes: what has to be true once it ships.

Your code
acme/the repo
src/approvals/a folder
approve-link.tsa file
decline.ts
tests/
approve-link.test.tsa test
README.md
Grove
AcmeProductStrategy
  • NotificationsFeature
    • P-240 Approve from emailProject
      • Plan
        • Approve by email
        • Works on any phone
        • In the audit trail
      • Delivery
        • #88 Approve links
GitHub
#88 Approve links in the emailOpen
Pull request · priya/approve-links → mainChecks
CodeRabbitAI review
Lint, typecheck, tests
Review from a code owner
Mergeyour call
Grove
P-240 Approve from emailProject
Notifications · plan in reviewPlan checks
Implementor agentagainst your code
Strategy agentfit with your strategy
Review from your teamsales, support, co-founder
Ready to buildyour call
Grove
P-240 Approve from emailProject
Notifications · deliveryOutcomes
Approve by emailReady for review
#88 Approve links in the emailMerged
Grove read the merged code
  • One tap approves up to $5,000, no sign-in
  • Over $5,000 goes to the second approver
Works on any phoneBuilding
#91 Approval email on small screensOpen
In the audit trailBuilding
#93 Log approvals from emailOpen
Mark the project doneyour call

Grove gets sharper with every decision you make in it

Other tools store your docs. Grove keeps your decisions and why you made them, reads what shipped and how your app works today, and brings all of it to every new idea before anyone has to remember.

  1. FebReach approvers wherever they are, without a second appProduct Strategy
  2. FebNo native mobile apps this yearProduct Strategy
  3. OctOver $5,000 waits for a second approverP-240 · raised by the Implementor agent
  4. Oct#88 Approve links in the emailmerged · src/approvals/approve-link.ts
  5. NowEvery approval checks its limit in one placeacme · src/approvals/limits.ts
Nov · a new idea

Let’s add an Approve button to the Slack post too.

GroveRead Product Strategy · a settled thread on P-240 · #88 · src/approvals/
  • Reach approvers anywhere
  • The $5,000 rule
  • #88 · approve-link.ts
  • limits.ts

It fits your bet on reaching approvers wherever they are.

P-240 settled that anything over $5,000 waits for a second approver.

#88 checks that limit in limits.ts, so a Slack button can use the same check. Want me to set it up that way?

  • It remembers why

    Every call stays with who made it and why, beside what shipped and what your strategy rules out.

  • It brings it back

    Each new idea is checked against what you’ve settled, what shipped and how your code works now.

  • It learns how you work

    When the same gap keeps coming back in your plans, Grove starts covering it before you ask.

Coding agents build whatever you hand them, fast. Rush the decisions, and customers get the wrong thing sooner. Grove does the product work around the build, so you build it right the first time.

Built for the work around the build

A tracker was where product and engineering met halfway. Now your developers’ agents build in days, and Grove does the product work on either side: vetting the idea, writing the plan, fielding questions and checking what shipped. You make the calls.

One system, three ways in

The real work happens with the Grove agent. Everyone else adds to it from the tools they already use, and it all lands in the same place.

  • Where the work happens

    The Grove agent

    It knows your strategy, features and projects end to end, so this is where ideas get vetted, plans get written and decisions settle.

    Vet this against our strategy
  • From your own chat

    Claude or ChatGPT

    Through Grove’s connector (MCP), bring context in and make quick edits without leaving your chat.

    Add my call notes to P-240
  • From the terminal

    Coding agents

    Through Grove’s command-line tool (CLI), agents pick up ready work and raise questions on the plan.

    grove project assign P-240
One Grove underneath
  1. Strategy
  2. Projects
  3. Plans
  4. Threads

Read-only access to your code, and your developers keep their tools

  • Grove reads your code to size the work and to answer your team’s questions about it.
  • Grove checks each merged pull request against its outcome, and a person marks it done.
  • Grove never writes to your code, merges a pull request or runs anything.
  • Code review stays with your developers, and so does their own tracker.
The rest of a CTO’s questions, SOC 2 among them, are answered on the CTO page. 

Questions

Grove

What is Grove?

Grove is product management software for founder-led startups. Your developers have agents that do their work, but your AI tools still wait for you to ask. Grove does for product what agents did for the build: it challenges the idea, scopes it into pieces worth building, turns each into requirements and designs, vets the plan before your developers’ agents pick it up, and checks that what shipped matches what you decided.

Is Grove an AI product manager?

No. Deciding what to build is the most human part of product management, and it stays with you. Grove does the work around it: it asks the hard questions, has separate agents check the plan, keeps every decision current while your developers build, and tells you whether what shipped matches it. A product department’s discipline, not a stand-in for your judgment.

I already use Claude. Why Grove?

Keep using it. Claude answers whoever asks, one chat at a time. Grove is the product process around it: one place where your team and their coding agents take every decision from the idea to what shipped, with the reasons kept. On top of that, Grove starts the product work itself, vetting ideas and checking plans and releases, with more automated every month. And it works inside Claude.

How is this different from a shared doc?

A shared doc holds what someone wrote on the day they wrote it. Grove holds the decision, carries a change into everything that depended on it, and checks what shipped against it.

Does Grove get better the more we use it?

Yes. Grove keeps every decision with who made it and why, reads what shipped and how your code works now, and brings all of it to each new idea before anyone has to remember. When the same gap keeps coming back in your plans, Grove starts covering it before you ask.

Decisions

What if Grove disagrees with me?

You make the call. Grove asks what the idea is for, what it would change for customers and whether it cuts against a decision you already made. If you go ahead anyway, Grove keeps your reason with the decision.

Who makes the final call?

You do. You set the strategy and make the calls that matter, and the team works the details against it. Grove asks, drafts and lays out the options, and every decision keeps who made it and why.

What happens when plans change mid-build?

Change the decision once. Grove carries it into every document that depended on it and keeps the reason, and your developers’ coding agents read the new version before they build.

Do I need to write a PRD first?

No. Bring the idea, even half formed. Grove asks what it’s for and drafts the spec as you work it through. If you already have a document, paste it in and start from there.

How is Grove different from a PRD?

A PRD is usually goals, non-goals and a few outcomes, and figuring out the rest falls to whoever builds it. In Grove that happens together. Your team shapes one living plan, the why and the what, not the how: diagrams, user flows, detailed business rules and high-fidelity designs built from your own UI. When a coding agent hits a question the plan doesn’t answer, the answer goes back into the plan.

Can we bring in what we already have?

Yes. Paste in a strategy document, a spec or customer feedback, and Grove works from it.

We don’t have a strategy written down

Most founding teams don’t. Grove asks you what a head of product would, and writes your vision, strategy, target customers and competitive landscape from your answers. From then on every idea is checked against them, and you change them as you learn.

Your team and its tools

Which coding agents does Grove work with?

Any coding agent that runs commands, such as Claude Code, Codex or Cursor. Grove’s command-line tool hands it the plan and the decisions behind it, and your developers keep working as they do today.

Does Grove work with ChatGPT as well as Claude?

Yes. Grove’s connector works in both, so anyone on the team can add to a decision from the chat they already use.

Do sales and customer success have to learn a new tool?

No. Most teams already work through Claude or ChatGPT, and those assistants already reach your CRM, your support desk and your docs. Through Grove’s connector, the same assistant brings what it finds into Grove, whether a customer’s request, a pattern in support tickets or a deal that hinges on a feature. It lands on the decision it’s about.

Will my developers have to change how they work?

Very little. They keep their own tools, and Grove connects to GitHub read-only. What’s new is Grove’s command-line tool, which their coding agent uses to read the plan and raise questions. Those questions come back to you with the context instead of becoming an agent’s assumptions. Anyone can take part from Grove’s app, from Claude or ChatGPT, or from a coding agent.

Your code

What does Grove need from our GitHub?

Read-only access to your repositories. Grove reads the code to size the work and answer questions about it, and reads pull requests to check them against the outcomes. It never writes to your code.

Does Grove work without GitHub?

No. Grove needs read-only access to your GitHub. Reading the code is how Grove sizes the work, answers questions about it and checks what shipped.

We already write specs in the repo for our coding agents

Keep them. A spec in the repo says what was decided on the day it was written. Grove holds the decision behind it, made with the people who aren’t in the repo, with what it serves, what was turned down and what has been decided since. Your agent reads both, and knows what not to build.

Getting started

How do we start, and what does it cost?

Request access, or book a call. If Grove fits, your team gets a two-week trial on one real feature, from the idea to the first piece your developers ship. After that, one monthly price covers five people, with each person after that added on. Month to month, cancel any time.

See pricing →

Get started

Talk to Grove’s founders

Thirty minutes on how your team decides what to build. You leave with our read on it.

Set Grove up with your team

Tell us about your company. If Grove fits, we set your team up for a two-week trial.