Private beta · Join the waitlist

Your codebase. Anyone builds. Everything's real.

Drop an idea in chat. Trot opens a branch, builds it, and replies with a live URL and a pull request. No tickets. No waiting. No handoffs.

No spam. We'll only email you about Trot early access.

Works from the tools your team already lives in

  • Slack
  • Microsoft Teams
  • Discord
  • Web

Idea to working prototype, in three steps.

You bring the idea. Trot brings the code — on a real branch of your real repo, ready to run.

  1. STEP 01

    Describe what you want

    Drop a message in Slack, Teams, Discord, or the web. "Add a usage banner when a team hits 80% of their seat limit." That's the whole brief.

  2. STEP 02

    Trot interviews you

    Trot asks the questions a good PM would ask: who it's for, what it should do, what "done" looks like. Answer in plain language. You walk away with a PRD you both agree on.

  3. STEP 03

    Trot builds it for real

    A clone of your repo spins up in an isolated sandbox. Trot writes the code, runs the build, starts the app, and hands back a live URL and a pull request — ready to review, share, or merge.

Built for the whole team, not just one role.

Product wants to validate. Engineering wants to scale. Sales wants to demo. Trot is the same tool for all of them, working on the same codebase.

Product

Stop drawing what you mean.

Skip the wireframes, the spec doc, the back-and-forth with engineering about feasibility. Describe the feature, get a working version on top of the real product, and put it in front of users this afternoon.

Validate ideas with real software, not Figma.

Engineering

More workstreams. Same team.

Every initiative runs in parallel on its own branch. While you review one PR, Trot is already drafting the next — building the feature, wiring the integration, writing the tests. Your team ships like it's three times bigger, without growing headcount.

Scale the team, not the headcount.

Sales & Support

Build the demo the customer asked for.

A prospect wants to see the integration that's not on the roadmap yet. A customer needs a one-off report. Trot builds it on a branch you can show off — without filing a ticket or pulling an engineer off another project.

Turn customer asks into prototypes, not promises.

Why Trot

Real code, real PRs
Trot works on a clone of your actual repo. Output is a branch and a pull request — not throwaway snippets in a chat window.
Isolated sandboxes
Every prototype runs in its own container with its own database. Experiments stay independent. Nothing touches production until you say so.
No bottleneck
No tickets, no scheduling, no waiting on the next sprint. Anyone with an idea can start one. Engineering reviews what graduates.
Lives where you work
Slack, Teams, Discord, web — Trot meets the team in the tools you already use, so adoption is one message away.

Get on the waitlist

We're letting in a small number of teams at a time. Tell us who you are and we'll reach out as soon as a slot opens.

No spam. We'll only email you about Trot early access.

Frequently asked questions

Still curious? Drop your email on the waitlist form and ask us anything in the reply.

    • Does Trot work on my codebase?

      Yes. Trot clones your real repo into an isolated sandbox and works there. You give it a spike.json that tells it how to install, build, and run your app, and it does the rest. We're starting with web apps that build and run with standard tooling.

    • Is the code Trot writes actually any good?

      It is real working code, on a real branch, in a real PR — meant to be reviewed, edited, and merged like any other engineer's work. Treat each prototype as a starting point for the conversation, not a finished feature.

    • How is this different from Cursor or Copilot?

      Those tools sit next to a developer who is already coding. Trot sits next to anyone — PMs, support, designers, founders — and produces a running app, not a code suggestion. You never open an editor to use it.

    • How is this different from Claude Code or Codex?

      Those are terminal-based coding agents for developers who already live in a shell. Trot runs in your team's chat — Slack, Teams, Discord, the web — and anyone can drive it. The output isn't a diff in your terminal; it's a running app on a branch of your repo, with a live URL and a pull request waiting for review.

    • What about secrets and production data?

      Each prototype runs in its own sandbox container with its own database. Production credentials never enter the loop unless you choose to wire them in. Nothing ships anywhere until a human merges the PR.

    • Which chat tools do you support?

      Slack is live today. Microsoft Teams, Discord, and a hosted web client are next. If your team lives somewhere we have not built yet, tell us on the waitlist form and we will prioritize it.

    • Will engineers still have a job?

      Yes — and a more interesting one. Trot handles the long tail of small ideas and one-off spikes that engineering never gets to. The hard, load-bearing work still needs you. It just stops being interrupted.

    • What's the pricing going to look like?

      We're still figuring it out with our beta teams. Expect a per-seat plan with usage-based limits on prototype runs. Waitlist members get founding-team pricing.

    • When will I get access?

      We're rolling teams in week by week. Joining the waitlist gets you a slot in the queue and an email when it opens up. Tell us your role and company and we may move you up.

    • Can I bring my own model or AI provider?

      Yes — Trot is bring-your-own from day one. Drop in your Anthropic or OpenAI API key and Trot uses it for every reasoning step. Your model, your rate limits, your bill.