Skip to main content

Produtyping and coding sessions

Produtyping: production-ready prototyping.

Experiment live in an isolated sandbox, or ask the agent to draft a plan for more ambitious tasks. Either way, the agent already knows your product: it starts from your specs and docs, and proposes the updates that keep them current.

Read the user guide

Two modes

Which one do I need?

Produtyping and coding sessions, side by side
ProdutypingCoding session
Use it whenYou want to see an idea working in your app.The change is bigger, and your team should agree on a plan first.
What you doDescribe the change in plain words and watch the app update.Start from a task, a bug report or a feature request. The agent drafts the plan.
Who reviewsYour engineers, or a Productmind Architect if you build alone.You or your team approve the plan, then review the pull request the same way.
You end up withA pull request with the change, and proposed updates to its specs and docs.An approved plan, then a pull request, and proposed updates to its specs and docs.
See how it worksSee how it works

Produtyping

What you see is what you ship.

Prototypes usually get thrown away and rebuilt. With produtyping, the agent changes your actual app while it runs in a sandbox of its own, so when the idea is right, it's already code your team can review.

1 / 2

Ask for a change and watch it happen.

Describe what you want in plain words: here, Pat, Software Inc's founder, asks for instalment payments. The agent edits the code while your app runs in an isolated sandbox, and the preview shows each change as it lands. Each change is saved to the session's own branch, and nothing reaches your main branch until someone merges it.

  • Who sees it. You, and any teammate with access.
  • Where it runs. In a dedicated Productmind sandbox, or on your own machine.

2 / 2

Open a pull request when it's right.

Happy with it? The agent opens a pull request, a change your engineers can review and merge, and writes a summary of what it did. It also proposes updates to the feature documentation, the technical documentation and the user guide the change affects. Your engineers comment on lines of the code, and the agent applies the comments to the same pull request.

  • No engineers yet? Ask a Productmind Architect, a person from our team, to review the code. Reviews are billed by the hour.

Meet Software Inc, a fictional company that sells invoicing software. Every name in these pictures is sample data.

Product memory

The agent already knows your product.

Ask in your product's language, not the code's. Every session starts from what Productmind knows about your product: its specifications, documents, business rules and code. You don't need to know where things live in the code.

Loaded before the agent plans or builds.

Each session gets the repositories of the linked applications, and the documents linked to those applications and features. It also gets the specification of each feature and of the features closest to it, and their business rules.

  • Conflicts go in the plan. When the code and a specification disagree, the agent is asked to name the conflict, not quietly pick one.
  • Private stays private. A private feature the session's creator can't see is left out.

Coding sessions

Plans that follow your product's rules.

Start a session from a task, a bug report or a feature request. The agent drafts an engineering plan from your specifications, business rules and linked documents, and is asked to name anywhere the code and a specification disagree. You or your team approve the plan before anything is built.

In control

Nothing ships until a person approves.

You bring the idea; people make the calls. In a coding session nothing is built until a person approves the plan, and Productmind never merges a pull request on its own.

  • Working with engineers? They see each session on a shared list and review its pull requests before they merge.
  • Building on your own? You approve each plan, and you can ask a Productmind Architect, a person from our team, to review the code before you merge.

See what's running, and what's waiting on you.

Sessions are grouped by who they belong to, so you can see what each person has running and what needs attention. A dot marks new activity since you last looked, and the list updates live.

  • Plan ready. When a plan is ready for review, everyone in the workspace sees it in their notifications.

Comment on the exact line you mean.

Feedback sits on the line it's about, and the agent answers in the same thread. Here, Riley asks for a week's notice on every reminder: the agent moves the plan to 7 days and says it will propose the rule for the feature's specification. Its approach cites the Billing flow document and the Engineering principles.

  • History. A plan you discard is saved to Document history first.

One conversation for the agent and the team.

Everything the agent did, and everything your team told it, is in one thread. Open any step to see what went in and what came out. When the agent asks a question or finishes a plan, anyone who can update the session can answer or approve.

See the change before you read the code.

When your app has a web front end, the agent opens it in a browser inside its sandbox and takes a screenshot of each page or state its change affects. The screenshots stay in the session's conversation, in one strip above the message box, so a reviewer sees what changed before opening the code.

  • Full size. Open any screenshot to see it full size, and step through the rest.

Review the pull request where it was built.

Read the changes in Productmind, with the pull request's checks beside them. Comment on a line, and Apply code revisions sends your comments to the agent. When a check fails you can see why, and the agent fixes the failures its own changes caused. For a second pair of eyes, ask a Productmind Architect for a code, architecture or product review, like the comment shown here.

Spec and doc updates come with the code.

Before it opens the code pull request, the agent proposes updates to the affected specifications and documents, each in its own pull request. Nothing changes until you approve and merge them.

Where it runs

Our cloud or your machine.

Every session lands in the same list and goes through the same review, wherever its code runs.

Productmind cloud

  • Install. Nothing on your machine.
  • Agent. PM runs its own agent.
  • Sandbox. One isolated sandbox for each session on Productmind's servers.
  • AI credits. Charges Productmind's AI credits pricing.
Read the guide

Your machine

  • Install. The Productmind CLI, on macOS or Linux.
  • Agent. PM orchestrates your own Claude Code or Codex agent.
  • Sandbox. Runs in your machine, up to three parallel sessions (configurable).
  • AI credits. Uses your own Claude Code or Codex accounts.
Set up the CLI
pm agent --name riley-laptop

Questions

We build Productmind with Productmind.

The workflow on this page is how we build our own product, so we hit the rough edges before you do. Here is what people ask before they try it.

  • Do I need to know how to code?

    No. You describe the change in plain words and watch it happen in the preview of your own app. The code is there if you wish a technical review.

  • I don't have an engineering team yet. Can I still use it?

    Yes. You approve each plan before anything is built. If you would like a technical review for complex tasks, you can ask a Productmind Architect to review the code before you merge. Reviews are billed by the hour.

  • Can my changes break the live product?

    Your changes run in a sandbox, not in your live product, and each one is saved to the session's own branch. Nothing reaches your main branch until a person merges its pull request: Productmind doesn't merge on its own.

  • How does my engineering team review what I made?

    On the session's page in Productmind. They read the changes with the pull request's checks beside them, comment on lines, and send the comments to the agent, which applies them to the same pull request.

  • What can the agent see, and where does our code go?

    A session gets the repositories, documents and specifications linked to its work, and leaves out a private feature its creator can't see. A session in our cloud runs on a runner that serves only that session, never another session or another organization.

    How we handle your code
  • Does it work with our stack and Git provider?

    Productmind works with GitHub, GitLab and Bitbucket. A live preview runs for a web service, or a monorepo that contains one: Productmind fills in how to install and run it, and you add the secrets, once per repository.

Start with one idea.
Let's build it.

Pick something small from your backlog, describe it in plain words, and see it running in your own app.

Get started