All posts
Product

How to ship a product change without a local dev setup

You can ship a product change without a local dev environment by making it in a cloud workspace that already runs your app. In Ensemble, you describe the change in the browser, an AI agent edits a branch, and a full preview (app, database, seed data) reloads beside the chat. You share the URL, and an engineer reviews the pull request.

5 min read

The wall is setup, not the idea

The hard part of shipping a small change is rarely the idea. It's the local setup that has to run before anyone can see the result.

Here's what "just run it locally" means for a typical product:

  1. Clone the repo, and get access to it first.
  2. Install the right versions of the language runtime, package manager and build tools.
  3. Run Postgres and Redis, at the versions the app expects.
  4. Get the environment variables and secrets, usually from an engineer, usually over Slack.
  5. Load test data, so the app isn't an empty shell.
  6. Start every service, in the right order, and debug whichever one fails.

Engineers do this once and forget how painful it was. For a PM, it's a week of favors, and it breaks again the next time the stack changes.

So PMs don't. They write a ticket instead. Say the change is small: switch the billing page copy and add a monthly/annual toggle for team plans. The change is about 20 lines. The ticket waits two weeks for engineering time, then comes back slightly wrong, because the ticket couldn't say everything the PM knew.

Engineers hit a different version of the same wall. The branch exists, and it's correct, but nobody without localhost can see it running. So the engineer ends up screen-sharing, or the change waits for staging.

AI coding tools have made the code part cheap. The part that hasn't gotten cheaper is everything around the code: running it, showing it, reviewing it. That's where the setup wall sits.

How to ship a change from the browser

In Ensemble Studio, shipping a change is four steps, and none of them happen on your laptop.

1. Open the project in Studio

An engineer has already connected the repo and declared the environment once: which services run, which databases they need, and what seed data to load. You open the project in the browser, and the app is there.

2. Describe the change in chat

Write it the way you'd explain it to an engineer:

Add a monthly/annual toggle to the billing page for team plans. Only workspace admins see it. Annual shows the discounted price. Don't change individual checkout.

Be specific about who sees the change and what must stay the same. Those are the details AI agents most often get wrong. Our spec template for AI coding agents covers the five things to include.

3. Watch it run

An AI agent edits a branch, and the preview beside the chat hot-reloads with real data. Sign in as the seeded admin account and flip the toggle. If something breaks, the logs are in a tab under the chat.

Keep iterating in plain language: "Make the toggle bigger on mobile." "Show the savings as a percentage." Each change shows up in the same preview.

Send the preview URL to whoever needs to see it. Workspace members open it directly; anyone else gets an expiring share link. When it's right, open the pull request. An engineer reviews the code, your CI runs, and the change merges through your normal process.

The ticket, the branch and the preview stay linked the whole way. If you work from Linear, you can start from a Linear ticket instead of from chat.

What's actually running in the preview

An Ensemble preview is the whole app for your branch, not a screenshot or a front-end mock.

It runs the services your team declared, Postgres and Redis where they're needed, and seed data, at its own URL. That's why you can test the admin-only toggle with a real admin account and a real team plan, instead of guessing.

Previews sleep when nobody is using them and wake when someone with access opens the link. You don't manage any of it. For the full picture, see what is a preview environment.

What "safely" means when a PM ships code

Your change runs in an isolated preview with its own secrets, and nothing reaches production until an engineer approves the pull request.

Three things make that true:

  • Isolation. Every preview runs separately, with secrets scoped to it. Your experiment can't break anyone else's preview, and it never touches production data.
  • Private links. Previews sit behind a login by default. Unreleased work doesn't end up on the open internet.
  • Engineers keep the keys. Protected branches (production, or staging and production) change only through review. Ensemble doesn't merge anything on its own.

This is usually what an eng lead wants to hear before saying yes. We wrote the longer version for them: how to let non-engineers ship code safely.

What engineers get out of it

Engineers stop being the only way a change can be seen. Instead of "can you pull my branch?", they get a pull request with a running preview attached, and a change they can click before they read the diff.

Context helps the code fit, too. Ensemble indexes the codebase, so the agent making the change can look up where things live and which patterns the team uses. That's covered in why coding agents re-read the repo.

FAQ

Can product managers ship code?

Yes, if the tooling removes local setup and keeps an engineer in the review loop. With Ensemble, a PM describes the change, sees it running on a preview, and opens a pull request that an engineer approves before it reaches production.

Do I need Git installed?

No. Studio runs in the browser. Your code still lives in GitHub, and Ensemble creates the branch and pull request for you.

Can I show the change to someone without an Ensemble account?

Yes. Create a share link and send it. Share links expire, and the person opening one doesn't need a paid seat.

Is a preview the same as a staging server?

No. Staging is one shared server that changes queue up for. A preview is one URL per change, with its own data, so nobody waits for anyone else.

Will this replace my engineers?

No. It lets you make the change and hand over something they can run and review, instead of a ticket they have to interpret.


Ensemble turns every change into a running copy of your real app, with its services and data, at a private link anyone on the team can open. What is Ensemble?

Stop shipping the hard way

Agents write the code. Ensemble runs it. Everyone clicks it: product people in the browser, agents in parallel, engineers deciding what merges.

Start free