Grok Build Tutorial: Build a Machine Learning Project

Grok 4.6 is the latest AI model powering Grok Build, designed for coding, agentic tasks, and complex knowledge work. Grok Build brings these capabilities directly to your terminal, where it can plan projects, create and edit files, install packages, run commands, test code, and fix errors with your approval.

In this guide, I will explore Grok Build, demonstrate its key features, and configure its cross-session memory, project instructions, reusable skills, and safety settings. 

We will then use it to build a complete end-to-end machine learning project, from setting up the environment and analyzing the data to training models, evaluating the results, and creating a prediction application.

What is Grok Build?

Grok Build is SpaceXAI’s coding agent that runs directly inside your terminal. 

It belongs to the same category of tools as Claude Code and OpenCode: you describe what you want to build in normal language, and the agent works with the files and tools on your computer to complete the task. To see how it holds up against its closest rival on a real task, read our head-to-head, Grok Build vs. Claude Code.

It can explore an existing project, create and edit files, install packages, run commands, test the code, identify errors, and fix problems.

Grok Build is also surprisingly user-friendly. You do not need to provide detailed coding instructions for every step, and it can reuse configurations from other coding agents, including agent skills, MCP configurations, and project settings. 

These featues makes the installation and setup process feel much smoother, especially if you are already using similar tools.

The main downside is the usage limit. 

Although Grok Build is available on the free plan, the free allowance can run out quickly when working on a complete project. 

The full SuperGrok plan costs $30 per month, which feels expensive compared with some competing tools. Claude Pro, for example, costs $20 per month and includes access to Claude Code.

Despite the pricing, Grok Build is a capable and approachable coding agent, especially for users who want an AI assistant that can do more than simply generate small code snippets.

Grok Build Key Features

Grok Build includes standard coding-agent features such as Plan Mode and project instructions through an AGENTS.md file. 

However, its memory, media generation, background automation, agent management, and extension system make it more useful for larger projects.

1. Cross-session memory

Grok can remember useful information across different sessions, including project commands, technical decisions, folder structures, and coding rules. 

This means you do not have to explain the same project every time you return.

2. Subagents

Grok can create independent child agents with their own context. 

For example, one agent could explore the codebase while another creates a plan, writes tests, or works on a separate feature.

3. Session fork and rewind

You can fork a session to test a different approach without losing your original conversation. 

Rewind also lets you return to an earlier stage when something goes wrong.

4. Git worktrees

Git worktrees allow Grok to work inside an isolated copy of the repository. 

This protects the main project while you test experimental features or run multiple agents at the same time.

5. Image and video generation

You can generate images and videos directly inside Grok Build using the /imagine and /imagine-video commands. 

This can be useful when building applications that need visual assets, mockups, or demo content.

6. Run loop

The /loop command lets Grok repeat a prompt at a selected interval. For example, you could ask it to check your tests, monitor a deployment, or report new errors every few minutes.

7. Vim mode

Grok Build includes a Vim Mode for users who prefer Vim-style keyboard controls while navigating the terminal interface. You can enable or disable it using /vim-mode.

8. Personas

Personas let you give agents different behavioral styles, areas of focus, or working rules. 

You can manage them using /personas and apply them to different subagents.

9. Agent dashboard

The Agent Dashboard provides a live overview of all your sessions. 

You can see which agents are working, waiting for input, completed, or failed, and open any session directly from the dashboard.

10. Hooks

Hooks let Grok automatically run commands or call an HTTP endpoint before or after specific events. 

You could use them to block dangerous commands, format code after edits, record tool usage, or send a notification when a task finishes.

11. Plugins

Plugins extend Grok Build with additional agents, hooks, MCP servers, language servers, and other functionality. Existing Claude Code plugins can also be discovered automatically without requiring a completely new setup.

12. Plugin marketplace

The built-in Marketplace allows you to browse and install plugins from configured sources directly inside Grok Build. You can open it using the /marketplace command.

How to Set Up Grok Build

Before building the machine learning project, we need to install Grok Build, connect our SpaceXAI account, and open it inside a dedicated project folder.

1. Install Grok Build

Open your terminal and run the command for your operating system.

For macOS, Linux, or WSL:

curl -fsSL https://x.ai/cli/install.sh | bash

For Windows PowerShell:

irm https://x.ai/cli/install.ps1 | iex

The installer downloads Grok Build and adds the grok command to your system.

2. Sign in to your SpaceXAI account

Next, sign in by running:

grok login

Grok Build will open a browser window where you can sign in to your SpaceXAI account and approve access. 

You normally only need to complete this process once.

3. Create the project folder

Create a separate folder for the machine learning project and move into it:

mkdir machine-learning-project
cd machine-learning-project

Now launch Grok Build inside the folder:

grok

Configure Grok Build for the Project

Before building anything, we will configure Grok Build to remember important project information, follow safer permission rules, and apply the same development instructions in every session.

1. Enable cross-session memory

Cross-session memory allows Grok to remember useful information after you close the terminal and return to the project later.

Start Grok Build with memory enabled:

grok --experimental-memory

Inside Grok Build, you can save an important note manually:

/remember This project uses uv for package management and pytest for testing.

You can also use /memory to view and manage saved information. 

Use memory for stable details such as important commands, technology choices, folder structures, and coding conventions. 

Temporary instructions should remain inside the current session. 

2. Add safe permission rules

Grok Build uses Ask mode by default, which means it requests approval before running tools that have not already been allowed.

We will add project-level permission rules to make normal development smoother while explicitly blocking risky actions. 

Ask Grok to prepare the configuration:

Create a safe .grok/config.toml configuration for this project. 
Allow normal file editing, Git inspection, testing, and linting, 
but deny access to secret files, destructive shell commands, Git pushes, 
force pushes, and changes outside the project folder.

3. Create permanent project instructions

Next, create an AGENTS.md file containing the rules Grok should follow throughout the project. 

Grok automatically loads this file whenever it works inside the repository, so you do not need to repeat the same instructions in every session. 

Use the following prompt:

Create a short AGENTS.md file for an end-to-end machine learning project. 
Protect the raw data, prevent data leakage, use reusable Python modules, 
manage packages with uv, add tests, commit every major change, and validate 
each stage before continuing.

Keep the instructions short and specific, as Grok is more likely to follow focused project rules consistently. 

4. Verify the configuration

Finally, check that Grok has discovered the project rules, settings, skills, plugins, and MCP servers:

grok inspect

Once everything appears correctly, we can begin building the machine learning project.

Grok Build Demo: Build an End-to-End Machine Learning Project

Now that Grok Build is installed and configured, we can use it to create the complete machine learning project from scratch.

1. Create the project plan

Start by switching to Plan Mode, so Grok can inspect the task and explain how it intends to build the project before changing any files:

/plan

Then, enter the following prompt:

Build an end-to-end machine learning project from scratch. 
Check whether Git and uv are installed, initialize the repository, 
create a uv environment, install the required packages, organize the project, 
download a toy dataset, analyze and clean the data, create visualizations, 
train and compare models, evaluate the best model, build a simple prediction 
CLI application, add tests, and document the results.

2. Review and approve the plan

Once the plan is ready, read through it carefully. You can ask Grok to add missing steps, remove unnecessary work, or change the tools and libraries it plans to use.

When everything looks correct, approve the plan. Grok will then start creating the project, installing packages, writing code, running tests, and showing you the changes it makes.

3. Continue after reaching the usage limit

While building the project, we reached the free usage limit. 

Large coding tasks consume more usage than normal chat requests, so this can happen quickly when Grok is analyzing data, training models, fixing errors, and running tests.

SuperGrok currently costs $30 per month and provides higher usage limits across Grok’s features. 

It is not cheap, but the additional allowance can be useful when you are building a complete project rather than testing a few small prompts.

After upgrading, return to the same session, type:

continue

Grok will pick up from where it stopped and continue building the project.

4. Review the final project summary

Once the work is complete, Grok provides a summary explaining what it created. This includes the data analysis, visualizations, model-comparison results, evaluation metrics, tests, project structure, and instructions for running the prediction application.

In our project, Grok trained a logistic regression model on the Palmer Penguins dataset. 

The best model achieved approximately 98% accuracy and an F1 score of 97.6%, which is an excellent result for this small classification project.

5. Explore the generated files

You can open the project folder in VS Code and explore the generated files one by one. 

This is useful for understanding how Grok organized the source code, data-processing pipeline, tests, reports, and command-line application.

Even though Grok created the project for us, it is still important to review the code and understand how each part works.

6. Test the prediction application

Open another terminal inside the project folder and run the following command:

uv run penguins predict \
  --bill-length 39.1 \
  --bill-depth 18.7 \
  --flipper 181 \
  --body-mass 3750 \
  --sex male \
  --island Torgersen

The CLI app processes the values using the same preprocessing pipeline and trained model used during evaluation. In our test, it returned the expected penguin species, confirming that the prediction application worked correctly.

Final Thoughts

Overall, I think Grok Build is a very good and surprisingly refined coding agent. 

You can use it through your SuperGrok subscription or connect it directly to the SpaceXAI API using an API key. 

More importantly, you are not limited to Grok models. 

Grok Build supports custom models through OpenAI-compatible and Anthropic-compatible APIs, which means you can also connect an open-source model running locally or use another API provider. 

You can follow the official custom model configuration guide to set this up. 

It also works smoothly with plugins, marketplaces, reusable skills, agents, hooks, and MCP servers. 

Grok can automatically discover existing Claude Code skills, plugins, MCP configurations, and instruction files without requiring you to set everything up again. 

The overall experience is very user-friendly. 

Updates are checked automatically when Grok Build starts, while the grok update command lets you manually install the latest version. 

Everything from installation and configuration to switching models and adding tools feels simple and well-designed. 

Compared with OpenCode, Grok Build currently feels like the more polished and mature product to me. 

It is already close to Claude Code in terms of features and the overall coding experience, and I expect it to continue improving. 

My main concern is still the cost and limited free usage, but apart from the subscription, I have high hopes for Grok Build.