Turn Projects into Demo Videos with AI

Coordinate AI agents to publish an evidence-backed portfolio launch.

Introduction

30 Second Summary

Great work can stay invisible when the evidence is scattered. A public launch needs a clear trail from what you built to what people can see.

In this project, you will use a three-Bot crew in Grok Bot to turn one completed NextWork project into a 30–60 second demo video. Your crew prepares a voice-matched post and opens a portfolio pull request that you review and merge.

What You'll Build

Picture opening your live portfolio, pressing play on a short walkthrough, and watching your finished project prove itself in under a minute.

By the end of this project, you'll have:

  • A 1280×720 demo video that replays your four proof moments as an H.264 MP4 under 10 MB.
  • A reviewable portfolio pull request that Builder Bot previews on the shared cloud computer before you merge it.
  • A voice-matched launch post grounded in your video, repository, and project documentation.
  • Secret Mission: Save the full crew flow as Launch This and start a complete launch from your phone with one repository URL.

Are there any prerequisites?

You need Grok Bot access, a finished project with a live URL, and the official Grok Bot download for macOS, Windows, or Linux.

Your existing portfolio repository must publish static files through GitHub Pages, or its README must document the build command Builder Bot can use for a branch preview.

Before We Start

A credible launch starts with one real completed NextWork project whose genuine implementation deserves a public portfolio page. This commitment keeps every later claim tied to your existing documentation and source repository.

Hire Your Launch Crew

Your finished project needs separate owners for visual proof, launch writing, and portfolio implementation. Clear approval boundaries keep public changes and personal posts under your control.

Grok Bot gives each owner a durable role plus access to one shared cloud computer. In this step, you will install the desktop app, hire the three-Bot crew, and connect GitHub.

In this step, get ready to:
  • Open Grok Bot on your operating system and confirm the required project sources.
  • Create Builder Bot, Demo Bot, and Writer Bot with lasting approval boundaries.
  • Start the capture-tool installation while you connect GitHub and create Launch Room.
Install Grok Bot and check your sources

The desktop app connects you to the same Bots and shared computer throughout the project. The official download page offers the supported build for macOS, Windows, or Linux.

  • Open the official Grok Bot download page in your browser.
  • Choose the download for macOS, Windows, or Linux.
  • Install Grok Bot from the downloaded file.
  • Press Cmd+Space (macOS), the Windows key (Windows), or open your application launcher (Linux).
  • Type Grok Bot and press Enter.
  • Choose Sign in on the welcome screen.
  • Complete authentication in the browser.
  • Return to Grok Bot.

You should see your signed-in Grok Bot home screen.

Can't reach the home screen?

Use the operating system build shown on the official download page. If browser authentication finishes without returning you to the app, close Grok Bot and open it again.

Help me open Grok Bot.

Builder Bot needs a finished source project and a portfolio it can preview before opening a pull request. Check both repositories now so the crew starts with real, accessible evidence.

  • Open the finished project's source repository in GitHub.
  • Confirm that your account can read the source repository.
  • Open your existing portfolio repository in GitHub.
  • Confirm that your account can create a branch in the portfolio repository.
  • Confirm that the repository publishes static files through GitHub Pages.
  • If the repository needs a build step, confirm that its README documents the exact build command.
  • Open the finished project's live URL.
  • Open the current live portfolio URL.

You should now have an accessible source repository, a working project URL, and a portfolio repository that Builder Bot can build or serve on the shared computer.

Hire Builder Bot, Demo Bot, and Writer Bot

Each Bot owns one part of the launch. Its description carries the lasting rules that still apply in future conversations.

  • Choose New in Grok Bot.
  • Select Create new Bot.
  • Name the first Bot Builder Bot.
  • Open Edit Profile.
  • Define Builder Bot as the owner of source coordination, portfolio branch changes, branch previews, and pull request creation.
  • State that Builder Bot never merges, publishes, changes accounts, enables paid usage, or shares a personal post.
  • Return to the Bots view.
  • Repeat the creation flow for Demo Bot.
  • Define Demo Bot as the owner of reproducible visual proof from the finished project.
  • State that Demo Bot never changes the finished project, exposes secrets, or invents evidence.
  • Return to the Bots view.
  • Repeat the creation flow for Writer Bot.
  • Define Writer Bot as the owner of source-backed drafts that follow your writing patterns.
  • State that Writer Bot preserves uncertainty and never publishes or posts on your behalf.
  • Return to the Bots view.

Keep the human approval line

Builder Bot can edit and preview a separate portfolio branch. Demo Bot can capture outcomes that already exist.

Writer Bot can prepare copy from approved sources. You retain authority over credentials, spending, merges, publication, and personal sharing.

You should see Builder Bot, Demo Bot, and Writer Bot in your Bots view. The full crew now has one owner for every handoff.

Start the tools and connect the crew

The capture tools take a few minutes to download. Start them now so Demo Bot can work in the background while you finish the GitHub connection.

  • Open Demo Bot's one-to-one conversation.
  • Open Demo Bot's shared computer.
  • Ask Demo Bot to open the terminal.
  • Start the browser and video tool installation by asking Demo Bot to run these commands:
cd /workspace
mkdir -p nextwork-launch
cd nextwork-launch
npm init -y
npm install playwright ffmpeg-static ffprobe-static
npx playwright install chromium

What do these tools add?

Playwright provides browser automation and records each browser page into a video file. The Chromium install gives the script a consistent browser to control.

FFmpeg converts the raw recording to H.264 MP4. FFprobe checks the finished codec, duration, and file size.

The downloads can take two or three minutes, so quiet terminal output does not mean the task has stopped. You should see installation logs begin before you continue.

Did an install command fail?

Ask Demo Bot to report the failing command without installing unrelated system packages. Keep the terminal output in the conversation so you can diagnose the exact failure.

Help me diagnose the capture-tool install.

  • Open Plugins in the Grok Bot sidebar.
  • Open Marketplace instead if that label appears in your version.
  • Find the GitHub plugin.
  • Choose Add.
  • Limit the authorization to the source and portfolio repositories when GitHub offers repository selection.
  • Complete the authorization in your personal browser.
  • Return to Grok Bot.
  • Confirm that the GitHub plugin shows as connected.

Keep credentials out of chat

Authentication can ask for a password, two-factor code, or CAPTCHA. Take over the shared computer and enter that information yourself.

Never paste credentials, recovery codes, or session cookies into a Bot conversation.

  • Switch to Builder Bot.
  • Type @ in the composer.
  • Attach the GitHub plugin.
  • Ask Builder Bot to identify the source repository.
  • Ask Builder Bot to identify the portfolio repository.
  • Choose New in Grok Bot.
  • Select Builder Bot, Demo Bot, and Writer Bot for the group.
  • Name the group Launch Room.

You should see all three Bots in Launch Room. Builder Bot should also name both connected repositories without requesting new credentials.

Can't read both repositories?

Check that GitHub authorization includes both repositories. Reconnect the plugin if one repository was excluded.

Help me check the GitHub connection.

Is a Bot missing from Launch Room?

Return to New and create the group again if one Bot is missing. Confirm that each of the three Bots appears in your Bots view before retrying.

Help me rebuild Launch Room.

Your crew and repository connection are ready. Demo Bot is finishing the capture-tool installation in the background, so Step 2 can begin with a direct readiness check.

Teach Demo Bot Your Launch Capture

Your launch crew is connected, and Demo Bot started downloading the capture tools while you finished the GitHub setup. Begin by confirming that Playwright, Chromium, FFmpeg, and FFprobe are ready on the shared cloud computer.

Teach a task will capture only the navigation and demo story. Demo Bot then turns that learned path into a separate scripted browser run that records itself at 1280×720.

The script produces the headline video without relying on a native recording control. Four numbered, annotated screenshots remain the fallback when the scripted recording fails.

In this step, get ready to:
  • Confirm that the background capture-tool installation finished.
  • Teach Demo Bot the four-part navigation and demo story.
  • Run and verify a scripted 1280×720 H.264 capture.
Confirm the tools and plan the story

Playwright controls the browser and records its viewport. FFmpeg converts that recording while FFprobe checks the finished media.

  • Return to Demo Bot's one-to-one conversation.
  • Ask Demo Bot whether the Step 1 installation finished.
  • Ask Demo Bot to open the terminal in /workspace/nextwork-launch/.
  • Verify the browser and video tools by asking Demo Bot to run:
npx playwright --version
node -e "const { chromium } = require('playwright'); (async () => { const browser = await chromium.launch({ headless: true }); console.log('Chromium ready'); await browser.close(); })();"
node -e "console.log(require('ffmpeg-static')); console.log(require('ffprobe-static').path);"

You should see a Playwright version, Chromium ready, and executable paths for FFmpeg and FFprobe.

Did a readiness check fail?

Ask Demo Bot to show the Step 1 installation output and identify the missing package. Rerun only the failed install command before repeating the readiness check.

Help me finish the capture-tool setup.

  • Record the live project URL here: https://your-live-project.example.
  • Choose the first visible outcome that introduces the finished project.
  • Choose the second visible outcome that proves its main interaction.
  • Choose the third visible outcome that proves the result persists or changes correctly.
  • Choose the final visible outcome that leaves the strongest result on screen.
  • Close any panel that shows credentials or personal data.
  • Close unrelated browser tabs.

What makes a useful demo story?

A useful demo moves through four observable outcomes in 30–60 seconds. Each moment should prove one claim without showing setup screens or private information.

The final frame should hold the strongest result long enough for a viewer to understand it.

Teach the navigation without recording

Teach-by-demonstration turns your clicks into a draft workflow. This teaching pass captures the route and timing only, so the deliverable remains a separate scripted run.

  • Open Demo Bot's computer view.
  • Choose Teach a task.
  • Describe the result as a reusable four-part navigation through the finished project.
  • State that this teaching pass must not create the deliverable video.
  • State that Demo Bot must not rely on a native recording control.
  • Start the teaching demonstration.
  • Move through the four proof moments in order.
  • Finish on the strongest project outcome.
  • Stop the teaching session.
  • Review the draft skill that Demo Bot creates.
  • Confirm that the draft lists the four navigation moments in order.
  • Confirm that the draft contains no native recording instruction.

You should see a draft skill that can replay the demo story without claiming it already produced a video.

Teach a task is unavailable?

If Teach a task is unavailable, complete the four moments once in Demo Bot's browser. Ask Demo Bot to create the navigation skill from your written four-part story and the completed task.

Help me create the navigation skill.

Build and test the scripted capture

The learned navigation now supplies the browser steps. The script adds explicit 1280×720 recording, H.264 conversion, media checks, and the screenshot fallback.

  • Ask Demo Bot to extend the draft skill with this scripted capture specification:
Name the private skill Launch Capture.
Use the learned four-part navigation as the browser action sequence.
Work only inside /workspace/nextwork-launch/.
Create capture-demo.js with Playwright, ffmpeg-static, and ffprobe-static.
Open [[LIVE_PROJECT_URL="https://your-live-project.example"]] in Chromium.
Set the browser viewport to 1280x720.
Set Playwright recordVideo size to 1280x720.
Replay the four learned proof moments with deliberate pauses.
Keep the complete walkthrough between 30 and 60 seconds.
Close the browser context so Playwright finishes the raw WebM recording.
Convert the WebM to demo.mp4 with H.264, yuv420p, and faststart settings.
Use FFprobe to confirm h264, 30–60 seconds, and a file size below 10 MB.
Save demo.mp4 and the verification report in /workspace/nextwork-launch/.
If recording or conversion fails, save four numbered, annotated screenshots in that folder.
Never expose credentials, change the finished project, or use a native recording control.
Run the scripted capture now and return the output paths plus the verification result.

How does the scripted run work?

Playwright records the browser context into WebM and saves the file when the context closes. The script then calls FFmpeg to create the H.264 MP4.

FFprobe checks the actual output instead of trusting its filename. The run passes only when the codec, duration, and file size meet every acceptance check.

The live dry run can take several minutes while Chromium replays the complete story and FFmpeg converts it. You should see Demo Bot report each stage instead of relying on a recording button.

  • Open /workspace/nextwork-launch/ on the shared computer.
  • Confirm that demo.mp4 exists when the scripted run succeeds.
  • Play demo.mp4 from beginning to end.
  • Confirm that the image is 1280×720.
  • Confirm that all four proof moments remain readable.
  • Review the FFprobe report for h264, a 30–60 second duration, and a size below 10 MB.

That is the headline deliverable working. Your launch folder now contains a sharp portfolio-ready video produced by the scripted browser run.

Did the scripted recording fail?

Use this path only after Demo Bot reports that the scripted recording or conversion failed. Ask Demo Bot to capture the same four proof moments as 01.png, 02.png, 03.png, and 04.png.

Require one viewer-facing annotation on each image. Save all four files in /workspace/nextwork-launch/ and keep Demo Bot's failure report beside them.

Help me use the screenshot fallback.

Live dry run required

This scripted path must pass a live dry run before the project leaves draft. Verify the video or the documented four-image fallback on the actual shared cloud computer.

Your visual evidence is ready and the capture method is saved as Launch Capture. Next, Writer Bot will learn your voice from two real posts and produce one source-backed draft.

Hand Off to Writer Bot

Your launch folder now contains a verified MP4 or its four-image fallback. Writer Bot needs those files, your source material, and two genuine posts before it can draft in your voice.

The shared workspace already gives Writer Bot access to Demo Bot's files, so the handoff uses paths instead of transferring attachments. This keeps one source of truth for the entire crew.

You will create one reusable voice skill and one source-backed draft. There is no editing loop in this step.

In this step, get ready to:
  • Point Writer Bot to the verified launch assets and source URLs.
  • Paste two past posts and save your writing patterns as a private skill.
  • Produce one draft and one portfolio implementation brief.
Share paths and verified sources

Each public claim needs a traceable source. The video proves the visible experience while the repository and project documentation support how you built it.

  • Open Launch Room.
  • Record the source repository URL here: https://github.com/your-name/your-project.
  • Record the project documentation URL here: https://your-project-documentation.example.
  • Tell Writer Bot that the primary visual asset is /workspace/nextwork-launch/demo.mp4.
  • If the recording failed, tell Writer Bot to use only 01.png through 04.png in the same folder.
  • Give Writer Bot the source repository URL.
  • Give Writer Bot the project documentation URL.
  • Tell Writer Bot to turn unsupported details into visible questions.
  • Ask Writer Bot to list every source and workspace path it can access.
  • Confirm that the reply names either the verified MP4 or all four fallback images.
  • Confirm that the reply includes both source URLs.

You should see one complete source inventory. Missing evidence should appear as a gap instead of becoming a claim.

Is the source inventory incomplete?

Ask Demo Bot to confirm the exact asset path in /workspace/nextwork-launch/. Ask Builder Bot to confirm the repository and documentation URLs through GitHub.

Help me complete the source inventory.

Save your voice and create one draft

Two genuine past posts reveal the choices you repeat across your writing. Writer Bot turns those patterns into durable rules before producing the only draft in this step.

  • Open Writer Bot's one-to-one conversation.
  • Copy one genuine past LinkedIn post from your personal browser.
  • Paste the first post into Writer Bot.
  • Copy a second genuine past LinkedIn post from your personal browser.
  • Paste the second post into Writer Bot.
  • Ask Writer Bot to extract patterns in openings, sentence length, structure, technical detail, tone, and closing style.
  • Require factual uncertainty to remain visible.
  • Require Writer Bot never to publish or post on your behalf.
  • Save the private skill as My LinkedIn Voice.
  • Type / in the desktop composer.
  • Confirm that Launch Capture appears in the skill menu.
  • Confirm that My LinkedIn Voice appears in the skill menu.

Your voice rules are now available across the crew. Writer Bot can apply them without keeping your personal LinkedIn session on the shared computer.

  • Create the single launch draft by giving Writer Bot this request:
Apply /My LinkedIn Voice to the verified source inventory.
Write one concise LinkedIn launch post for the finished project.
Use the video or documented screenshot fallback as visible evidence.
Name the project outcome and the main build choice.
Support every factual claim with the repository, documentation, or visual evidence.
Turn unsupported details into questions instead of inventing them.
Do not publish, post, or open LinkedIn.
Save the only draft as /workspace/nextwork-launch/linkedin-draft.md.

Why separate voice from facts?

The skill controls writing patterns while the source inventory controls facts. Keeping those jobs separate helps the draft sound personal without weakening its evidence.

  • Open /workspace/nextwork-launch/linkedin-draft.md.
  • Read the single draft from beginning to end.
  • Confirm that every factual claim maps to the source inventory.
  • Confirm that Writer Bot did not open or post to LinkedIn.

You should see one voice-matched post saved beside the launch assets. You decide later whether to share it personally.

Prepare Builder Bot's implementation brief

Builder Bot needs one compact brief that combines the approved evidence, portfolio rules, and preview method. That brief becomes the acceptance checklist for the pull request.

  • Ask Writer Bot to point Builder Bot to /workspace/nextwork-launch/linkedin-draft.md.
  • Ask Builder Bot to create /workspace/nextwork-launch/portfolio-brief.md.
  • Require the brief to use demo.mp4 when the verified video exists.
  • Require the brief to use the four fallback images only when the recording failed.
  • Require the brief to preserve the existing portfolio design.
  • Require the brief to follow the static GitHub Pages structure or the build command documented in the portfolio README.
  • Require Builder Bot to preview a separate branch on the shared cloud computer.
  • Require Builder Bot to stop after opening the portfolio pull request.
  • Open /workspace/nextwork-launch/portfolio-brief.md.
  • Confirm that it names the correct visual asset path.
  • Confirm that it names the repository's preview command or static-file path.
  • Confirm that it keeps merging and publication under your approval.

You should see one draft plus one implementation brief centred on the verified launch evidence.

Your crew now has approved inputs for the portfolio change. Next, Builder Bot will verify repository write access, preview the branch, and open a pull request for your review.

Ship the Portfolio Update

Your crew has produced a verified launch asset, one source-backed post, and one portfolio implementation brief. Builder Bot now turns those inputs into a branch you can inspect before anything becomes public.

The GitHub plugin proves that Builder Bot can read the repositories. A separate shared-computer checkout and push check proves that the terminal can open the pull request without exposing your credentials.

You remain the only person who merges the pull request. That merge triggers the existing GitHub Pages publication flow.

In this step, get ready to:
  • Check remaining usage and verify repository push access.
  • Build and preview the video card on a separate branch.
  • Review, merge, and verify the live GitHub Pages update.
Check usage and repository access

This branch build uses the shared cloud computer and your included Grok Bot allowance. Check the remaining usage before authorizing the repository work.

  • Open the Grok Bot account menu.
  • Choose Settings.
  • Open Usage & Billing.
  • Check the remaining weekly included usage.
  • Confirm that on-demand usage remains disabled.

You should see enough included usage for one portfolio branch run while on-demand usage stays off.

Is the included usage low?

Your launch pack is already saved in /workspace/nextwork-launch/. Pause here if the included allowance is low, then resume after it resets.

Help me pause before the branch run.

Repository authentication can feel risky because the shared terminal may ask for GitHub access. You will take over for any password, two-factor code, CAPTCHA, or approval screen, so no credential enters the conversation.

  • Open Builder Bot's one-to-one conversation.
  • Ask Builder Bot to open the portfolio repository on the shared cloud computer.
  • Ask Builder Bot to fetch the latest default branch.
  • Ask Builder Bot to create a separate branch named portfolio-launch-video.
  • Take over the shared computer if GitHub requests authentication.
  • Enter the required credential or approval yourself.
  • Return control to Builder Bot.
  • Ask Builder Bot to push the new branch before editing files.

You should see portfolio-launch-video on GitHub. That remote branch proves the shared computer can push changes without revealing your credentials.

Can't push the preview branch?

Confirm that the connected GitHub account can create branches in the portfolio repository. If authentication appears, take over and complete it yourself instead of sending credentials to Builder Bot.

Help me verify push access.

Build and preview the video card

Builder Bot follows the portfolio repository itself instead of assuming a framework. Static repositories can be served directly while built sites use the command documented in the README.

  • Ask Builder Bot to open /workspace/nextwork-launch/portfolio-brief.md.
  • Ask Builder Bot to inspect the portfolio README.
  • Ask Builder Bot to identify whether the repository publishes static files directly.
  • If a build command is documented, ask Builder Bot to use that command for the preview.
  • Ask Builder Bot to preserve the existing framework and design system.
  • Ask Builder Bot to add one project card for the finished project.
  • Ask Builder Bot to copy the verified visual asset into the repository's existing asset structure.
  • Require visible video controls when demo.mp4 is available.
  • Require the card to show the approved project summary.
  • Require the card to link to the source repository and project documentation.
  • Require the card to use the four-image fallback only when no verified MP4 exists.
  • Ask Builder Bot to run the repository's documented build or static preview.
  • Ask Builder Bot to open the branch preview in the shared browser.

Video acceptance checks

The video must display at 1280×720, use H.264 inside an MP4, run for 30–60 seconds, and stay under 10 MB.

The four numbered images replace the video only when the Step 2 live dry run documented a recording failure.

Before Builder Bot tests the preview, do you expect the embedded video to play from start to finish?

  • Ask Builder Bot to press the video's play control.
  • Ask Builder Bot to watch the complete walkthrough.
  • Ask Builder Bot to confirm that all four proof moments remain readable.
  • Ask Builder Bot to confirm that the card layout stays intact while the video plays.
  • Ask Builder Bot to capture evidence from the working branch preview.

You should see the new project card in the branch preview and watch the full 1280×720 video play from beginning to end.

Does the branch preview fail?

Check that Builder Bot used the build command documented in the repository README or served the existing static files. Confirm that the video path matches the repository's asset structure.

Help me troubleshoot the branch preview.

  • Ask Builder Bot to commit the reviewed branch changes.
  • Ask Builder Bot to push the updated branch.
  • Ask Builder Bot to open a pull request through GitHub.
  • Require the pull request to include the branch preview evidence.
  • Require the pull request to list the codec, resolution, duration, and file size checks.
  • Require Builder Bot to stop after opening the pull request.
Review, merge, and verify the live page

The pull request records the exact repository change while the preview proves it works. Your review is the final approval before GitHub Pages receives the update.

  • Open the portfolio pull request in GitHub.
  • Review the pull request diff.
  • Confirm that the correct video or documented fallback assets are included.
  • Review Builder Bot's branch preview evidence.
  • Review the available repository checks.
  • Confirm that Builder Bot stopped without merging.

Merging publishes the reviewed repository change through your existing deployment. This is the public action reserved for you.

  • Choose Merge pull request in GitHub.
  • Choose Confirm merge.

GitHub Pages can take up to 10 minutes to publish the new commit. That wait is expected while the reviewed video card moves to the live site.

Before you check the live page, do you expect the published card to match Builder Bot's branch preview?

  • Wait for the GitHub Pages deployment to finish.
  • Open the live portfolio project page.
  • Press the video's play control.
  • Watch the walkthrough from beginning to end.
  • Confirm that all four proof moments remain readable.
  • Confirm that the layout matches the approved branch preview.

Your published portfolio now plays the complete project demo. The crew prepared the pull request, and your merge made the change public.

  • Open /workspace/nextwork-launch/linkedin-draft.md.
  • Add the live portfolio project page URL to your personal copy if you want to share it.
  • Publish the post personally only if you choose to share it.

Is the live video missing?

Confirm that the pull request shows as merged. Give GitHub Pages the full 10-minute window if the latest deployment is still running.

If the page loads without the video, compare the deployed asset path with the path that worked in the branch preview.

Help me troubleshoot the live video.

Secret mission

Launch From Your Phone

Save the proven capture, writing, and portfolio handoffs as Launch This. Then send Demo Bot one repository URL from your phone and return to a complete launch kit with an open, unmerged portfolio pull request.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your launch resources, pause future Bot work, or remove the files and public portfolio update. No scheduled workflow remains, but future Bot requests still use your included allowance.

Resources you used:

  • Builder Bot, Demo Bot, Writer Bot, and the Launch Room collaboration history.
  • The private skills Launch Capture, My LinkedIn Voice, and Launch This.
  • The durable /workspace/nextwork-launch/ folder containing tools, launch assets, reports, and drafts.
  • The Grok Bot GitHub plugin, GitHub-side authorization, and shared browser session.
  • The published portfolio project card and its embedded video or fallback images.

Keep everything running

No action needed. Choose this if you want the crew, skills, launch evidence, and public portfolio card available for another project.

  • Keep /workspace/nextwork-launch/ as the crew's evidence workspace.
  • Keep the GitHub plugin connected only while you still want approved repository work.
  • Keep Builder Bot, Demo Bot, Writer Bot, and Launch Room available for future handoffs.
  • Keep Launch Capture, My LinkedIn Voice, and Launch This enabled for the Bots that use them.
  • Keep the published project card and visual assets live.

Pause - I'll come back to this later

Stop starting new Bot work while keeping the crew, files, skills, repository history, and public page available for later.

  • Wait for any active Bot task to finish or send Stop now in its conversation.
  • Turn off notifications for Builder Bot, Demo Bot, and Writer Bot if you do not need completion alerts.
  • Keep on-demand usage disabled.
  • Leave the private skills and /workspace/nextwork-launch/ in place.
  • Leave the portfolio card live until you are ready to remove it.

Delete - I don't want to use this again

Remove the public portfolio change first, then delete the workspace and revoke access. Finish by disabling the private skills and deleting the Bots you no longer need.

Remove the public portfolio card
  • Ask Builder Bot to create a branch that removes the project card and its visual assets.
  • Ask Builder Bot to follow the repository README or static-file structure for a branch preview.
  • Ask Builder Bot to open a removal pull request through GitHub.
  • Review the removal pull request yourself.
  • Choose Merge pull request.
  • Choose Confirm merge.
  • Wait up to 10 minutes for GitHub Pages to publish the removal.
  • Confirm that the live portfolio no longer shows the project card or visual assets.
Delete the launch workspace

Deleting the launch folder is permanent. It removes the Playwright project, downloaded package files, demo assets, verification reports, and drafts together.

  • Delete /workspace/nextwork-launch/ from the shared cloud computer by running:
rm -rf /workspace/nextwork-launch/
  • Inspect /workspace.
  • Confirm that nextwork-launch no longer appears.
Disconnect Grok Bot from GitHub
  • Open Plugins in Grok Bot.
  • Open Marketplace instead if that label appears in your version.
  • Open the GitHub plugin.
  • Choose its disconnect control.
  • Confirm that GitHub no longer appears as connected in Grok Bot.
Revoke GitHub-side authorization
  • Open your profile menu on GitHub.
  • Choose Settings.
  • Open Applications under Integrations.
  • Check Authorized GitHub Apps and Authorized OAuth Apps for the matching Grok Bot authorization.
  • Choose Revoke for the matching authorization.
  • Open Installed GitHub Apps if Grok Bot was installed on your personal account.
  • Choose Configure beside the matching app.
  • Choose Uninstall if you want to remove its repository access completely.
Disable the private skills
  • Open Settings in Grok Bot.
  • Open Plugins.
  • Open Yours.
  • Disable Launch Capture for every remaining Bot.
  • Disable My LinkedIn Voice for every remaining Bot.
  • Disable Launch This for every remaining Bot.

Private-skill deletion is not documented

The current public Grok Bot documentation explains how to enable private skills per Bot, but it does not document a permanent private-skill deletion control. Leave the skills disabled if your app does not show a documented delete option.

Delete the launch crew

Deleting a Bot is irreversible. It removes that Bot's profile and conversation, while shared computer files and sign-ins must still be cleaned up separately.

  • Remove Builder Bot, Demo Bot, and Writer Bot from Launch Room's group members.
  • Hide the empty Launch Room conversation from the sidebar.
  • Open Builder Bot's sidebar menu.
  • Choose Delete.
  • Repeat the deletion for Demo Bot.
  • Repeat the deletion for Writer Bot.
  • Confirm that the three Bots no longer appear in the active Bots list.

Nice Work!

Nice Work!

You did it! Your Grok Bot launch crew turned one completed NextWork project into a demo video, a portfolio page that plays it, and a voice-matched post you can choose to share personally.

You learned how to:

  • Built a three-Bot launch crew with separate owners for capture, writing, and portfolio implementation.
  • Created a scripted 1280×720 demo that converts browser automation footage into a verified H.264 MP4 under 10 MB.
  • Published a reviewed portfolio project card through GitHub Pages while keeping the merge and optional post sharing under your control.
  • If you completed the Secret Mission, saved the full crew flow as Launch This and started a complete launch from your phone.

Ready to quiz yourself?