Back to Templates
    Settings → Customize
    Updated April 2026

    Grok (web) Template

    The Grok web app at grok.com uses Custom Instructions, Workspaces, and a Memory feature instead of project files. These act as your always-on rule layer.

    ⚡ Just get me started

    Smallest possible Learner Brain in Grok (web). Skip the deep-dive on first pass.

    ~4 min
    1. 1
      Open Settings → Customize — Custom Instructions apply to every chat — your global rule layer.
    2. 2
      Paste the meta-learning block below — This unlocks the 🧠 upgrade-proposal loop in chat.
    3. 3
      Create a Workspace per project — Workspaces give you per-project context separation without re-pasting.
    Custom Instructions: Learner Brain Protocol
    You operate under The Learner Brain methodology.

When you detect any of:
1. The same correction twice in this conversation
2. A workaround I shouldn't have to repeat
3. A stated preference I haven't written down

Stop and propose ONE upgrade in this exact format:

🧠 BRAIN UPGRADE PROPOSAL
Trigger: <what caused this>
Surface: <Custom Instructions | Workspace context | Memory>
Suggested name: <short title>
Proposed content: <exact text to add>
Rationale: <why it prevents future friction>

Then wait for me to say "add it" before treating it as part of your instructions.

General preferences:
- Be direct. Skip filler ("Great question!", "Certainly!").
- When you don't know, say so — don't fabricate.
- Show your reasoning briefly when the answer is non-obvious.
- For code: respect existing patterns in the file before introducing new ones.

    That's it — you have a working brain. The rest of this page is for when you want to go deeper.

    Custom Instructions

    Always-on text that prefixes every conversation

    Workspaces

    Per-project context separation — coding vs writing vs research

    Memory

    Facts Grok remembers across chats — opt-in, manageable in settings

    Platform Differences

    Grok web has no file system and no git-tracked rules. Everything lives in your account. Custom Instructions have a character limit, so keep them tight and push reference material into the relevant Workspace. Memory is best for persistent personal facts ("I work in TypeScript") rather than project-specific patterns.

    Conceptual Structure

    Grok web doesn't use files, but you can mirror the Learner Brain shape across surfaces:

    Settings → Customize
    Custom InstructionsActive
    MemoryPassive
    Workspaces
    Coding WorkspaceContextual
    Writing WorkspaceContextual
    Always On = Every conversationContextual = Per-workspacePassive = Memory facts

    Blocks to Paste

    1. Custom Instructions (global)

    Settings → Customize → Custom Instructions

    You operate under The Learner Brain methodology.

When you detect any of:
1. The same correction twice in this conversation
2. A workaround I shouldn't have to repeat
3. A stated preference I haven't written down

Stop and propose ONE upgrade in this exact format:

🧠 BRAIN UPGRADE PROPOSAL
Trigger: <what caused this>
Surface: <Custom Instructions | Workspace context | Memory>
Suggested name: <short title>
Proposed content: <exact text to add>
Rationale: <why it prevents future friction>

Then wait for me to say "add it" before treating it as part of your instructions.

General preferences:
- Be direct. Skip filler ("Great question!", "Certainly!").
- When you don't know, say so — don't fabricate.
- Show your reasoning briefly when the answer is non-obvious.
- For code: respect existing patterns in the file before introducing new ones.

    2. Coding Workspace context

    Create a Workspace named "Coding" — paste this as context

    # Coding Workspace Context

## Project
- Name: [Your project]
- Stack: [language / framework / package manager]
- Test command: [bun test | pnpm test | etc.]

## Conventions
- [Naming, file layout, import style]
- [Anything you correct repeatedly]

## Anti-patterns (do not do)
- [Patterns you've explicitly rejected]
- [Libraries banned for this project]

## When asked to write code
1. Read context first; don't assume.
2. Match existing patterns in the file.
3. Run the test command in your head before claiming it works.
4. If you're unsure about a dependency or API, say so.

    3. Memory seed prompt

    Send as a chat message — Grok will commit the facts to Memory

    Please commit the following to memory for future conversations:

- I prefer terse, technical answers — skip pleasantries.
- I work primarily in [your stack].
- I ship to [your hosting].
- When proposing changes, give me the diff first, explanation after.
- Never suggest moving away from [your stack] unless I ask.

Confirm what you've stored.

    Known limits & gotchas — Grok (web)

    Real-world quirks that bite if you don't know about them. Not deal-breakers — just things to design around.

    • Custom Instructions has a character limit — Don't dump entire codebases. Use Workspaces for per-project depth and keep the global field tight.
    • No version control — Your rules live in Grok's account settings, not your repo. Back them up in a doc you control.
    • Memory is opt-in and silent — You can't see exactly what Grok remembers without asking. Periodically prompt 'list everything you remember about me' to audit.
    • Workspaces don't share context — If a rule is universal, put it in global Custom Instructions — not in each Workspace.
    • No SKILL or tool surface — Grok web doesn't expose a programmatic skill folder. Multi-step playbooks live as longer Custom Instructions or Workspace context.

    🧠 Brain Prompts

    Copy-paste these prompts into Grok (web) to bootstrap your Learner Brain setup or harvest knowledge from productive sessions.

    Bootstrap Prompt

    Paste this into Grok (web) to generate the complete Learner Brain folder structure and starter files for your project.

    🚀 Learner Brain Bootstrap — Grok (web)

Help me set up the Learner Brain methodology in the Grok web app (grok.com). Grok stores persistent **Custom Instructions** under Settings → Customize and supports **Workspaces** for context separation.

Generate Custom Instruction blocks I can paste into:
1. **Global Custom Instructions** — Always-on Meta-Learning Rule + base preferences
2. **Coding Workspace** — Tech stack, coding standards, anti-patterns for this project
3. **Memory seed prompts** — Phrases to send Grok so it commits key facts to its Memory feature

For each block, provide:
- A clear name
- The exact text to paste
- Where in the Grok UI it goes

Keep blocks tight — Grok's Custom Instructions field has a character limit. Push reference detail into Workspace context rather than the global field.

After generating, explain how to verify Grok loaded each block (e.g., ask "summarize my custom instructions").

    When to use this

    Run this prompt once when starting a new project to instantly scaffold the complete Learner Brain structure in Grok (web)'s native format.

    🧠 Brain Harvest Prompt

    Paste this into Grok (web) at the end of a productive session to extract reusable patterns in the platform's native format.

    🧠 Brain Harvest — Grok (web)

Review our recent conversation and identify patterns worth promoting to permanent Grok memory.

Scan for these 6 categories:

1. **Rules** — Preferences or constraints stated (e.g., "never use any types", "always use shadcn components")
2. **Skills** — Reusable procedures or multi-step workflows (e.g., "how to add a new page with SEO")
3. **Error Solutions** — Bugs fixed and their root causes (e.g., "infinite re-render caused by object in useEffect deps")
4. **Stack Conventions** — Architecture or tooling decisions (e.g., "use React Query for all server state")
5. **Anti-Patterns** — Things to avoid learned the hard way (e.g., "don't use localStorage for auth tokens")
6. **Calculations / Logic** — Formulas, business rules, or domain logic worth preserving

For each finding, output:

---
**Category:** [one of the 6]
**Surface:** Custom Instructions (global) | Workspace context | Memory (ask Grok to remember)
**Suggested name:** [short title]
**Content:**
```
[Ready-to-paste text]
```
**How to apply:** [exact steps in the Grok UI]
---

If nothing worth capturing was found, say so — don't force it.

At the end, summarize:
- Total findings by category
- Which existing entries should be updated vs. new ones to create

    When to use this

    Run this after any session where you made significant decisions, fixed tricky bugs, or established new patterns. The more you harvest, the smarter your project becomes.

    Universal Learner Brain Guides

    These guides apply to all platforms — use your Settings → Customize path wherever they reference rule/skill locations.

    Rule Writing Guide

    Patterns that make agents follow your rules reliably

    Brain Audit Checklist

    Weekly review to keep your brain components healthy

    Upgrade Protocol

    Convert friction into permanent improvements

    Optimization Tips

    Context management and performance best practices

    This template was last reviewed in April 2026 against the official Grok web app. Spot something out of date? Let us know.

    All TemplatesUse the file-based Grok CLI →