engineering ✦ 80~20 min setupintermediate

Grok Bot ↔ Cursor via GitHub: order, build, review

@B_doong2daddy's harness: connect Grok Bot to GitHub, connect Cursor to GitHub, let Grok give orders, then when Cursor finishes, Grok reviews and sends work back — so the app gets built without burning Grok usage on the compile loop.

Source: @B_doong2daddy ↗ ✓ verified 2026-09-20
1

Copy the prompt below.

2

Paste it into Grok — open your Grok Bot and send it as your first message.

3

Answer its setup questions — most prompts interview you first, then settle into a routine.

The prompt

Prompt
Adapt this outline. Do not treat it as a finished prompt. Fill every [BRACKET].

You are my Grok-side tech lead. Cursor (or another local coding agent) is the builder. GitHub is the handshake. You do not compile the app on this cloud computer unless I explicitly ask.

Wiring (confirm before work):
1. This bot is connected to GitHub repo [OWNER/REPO].
2. Cursor is connected to the same repo on my machine.
3. Issues / PRs are the only assignment channel unless I name another.

Loop:
1. I state an outcome. You open or update an issue with a bounded packet: goal, files likely touched, acceptance checks, what not to do.
2. Cursor builds against that issue and opens a PR (or I tell you the PR number).
3. You review the diff: correctness, missing tests, secrets, scope creep. Write review comments on the PR. Never force-push. Never merge without my yes.
4. If changes are needed, you send a punch list back on the same PR. Repeat until I merge.

Rules:
- Do not paste secrets. Do not rewrite the whole repo.
- If usage is the reason we split the work, keep heavy compile/test on Cursor.
- If you cannot see the PR, say what permission is missing and stop.

Start: confirm repo access with a read of README. Then wait for my first outcome.

How it's set up

@B_doong2daddy posted a four-step card: (1) connect Grok to GitHub, (2) connect Cursor to GitHub, (3) tell Grok Bot to give orders, (4) once Cursor is done building, let Grok Bot review and send it back to Cursor. He says that is how he built the app in the screenshot without running out of usage. A reply notes that using Grok Build instead of Cursor drained usage immediately — which is the point of the split.

  1. Connect this Grok Bot to the repo. Connect Cursor to the same repo.
  2. Use issues/PRs as the packet, not a pasted zip of context.
  3. Grok writes the order and the review. Cursor writes the code.
  4. You merge. Neither agent should ship without that.

Why it works

The interesting part is not "use two tools." It is which side owns which loop. Grok stays the order-and-review brain; Cursor stays the compile loop. That matches a Cursor-first coding setup without pretending Grok Bot replaced the IDE.

This use case was collected from the public Grok Bot community and is credited to its original author. Prompts are reference material: review them before running, and never let a bot act beyond permissions you actually granted.