I think a lot of people aren't using Grok Bot to its full potential, because knowing how to automate things is actually quite a difficult skill to learn. I wrote this post to break down how I approach automating anything with Grok Bot! https://t.co/FwJ4AwuHeU
This is F*CKING scary... Lauren Tan, a SpaceXAI engineer - cloned HERSELF into a prompt...
Then she shipped the command that clones you
Her own skill is called /poteto-mode. Her agents read it and work the way she does.
/automate-me builds the same thing for YOU. I turned it into one Grok Bot prompt:
Step 1 → Mine
• It reads 2 to 4 weeks of your history in 3 slices.
• Your style, how you delegate, what "done" means to you, every "dumb it down".
Step 2 → Filter
• A habit seen in 2+ slices becomes a rule.
• Seen once? Noise. Dropped.
Step 3 → Ask
• ONE multiple choice question, then a follow up on what you picked.
• Never 20 questions.
Step 4 → Write
• It drafts your own -mode file, only where you have a real rule.
• Then it cuts every line. "A mode skill is not a manual."
Step 5 → Install
• With your OK, every Bot gets one line: follow your mode.
• Next run it only learns what changed.
You end up with agents that work like you, not like a default chatbot.
Her clone is poteto-mode. The prompt for yours is in the first reply ↓
holy sh*t
SpaceXAI engineer Lauren Tan shared her method for keeping agent work tied to team decisions:
paste this into your agent to validate actions against permissions
Prompt:
request.bind {
origin := [SLACK_THREAD]
requester := [REQUESTER]
repo := [REPO]
goal := [TASK]
acceptance := [OBSERVABLE_RESULT]
grants := [EXISTING_AUTHORIZATIONS]
paths := [PERMITTED_EDIT_PATHS]
stop_when := [LIMIT_OR_BLOCKER]
}
authority.resolve {
IDENTIFY requester from authorized context
READ repository rules and source-thread decisions
RESOLVE permitted actions, targets and required approvals
CHECK host tools and actual access
KEEP unresolved authority explicit
ASSERT understanding != authorization
ASSERT passing_checks != release_approval
REUSE existing grants without asking for them again
}
action.inspect {
verb := [PROPOSED_ACTION]
target := [FILE_SERVICE_OR_RESOURCE]
effect := [EXPECTED_STATE_CHANGE]
authority := [SUPPORTING_GRANT]
source := [REQUEST_OR_DECISION_LINK]
}
action.route {
ALLOW when:
requester authority covers the action
target and effects remain within scope
required tools and access are available
applicable approval conditions are satisfied
CLARIFY when:
goal or acceptance is ambiguous
instructions conflict
missing context changes the correct action
available authorized sources cannot resolve the question
ESCALATE when:
additional permission or access is required
sensitive infrastructure, database or deployment work lacks approval
the change expands into an unrelated redesign
a product or release decision remains unresolved
}
context.sync {
ASSIGN one accountable task owner
ATTACH thread links, repo constraints and acceptance checks
COORDINATE shared files before parallel edits
REFRESH the brief when team feedback changes the task
RETAIN the message supporting each scope change
REASSESS checks affected by revised requirements
}
worker.cycle {
PIN baseline.commit
PIN baseline.worktree_diff
SAVE reproduction inputs, setup and expected result
PRESERVE unrelated changes and a rollback path
READ relevant implementation
TRACE calls and data flow
SEPARATE observations from hypotheses
REPRODUCE before selecting a correction
PATCH one logically cohesive change
RUN the actual application
REPLAY the affected scenario
INSPECT outputs, errors and resulting state
ON mismatch -> diagnose cause -> correct -> replay
ON missing prerequisite -> record blocker and next action
ON stop condition -> halt and return collected evidence
CLEAN only resources created by this run
KEEP evidence artifacts
}
proof.match {
build -> compiler and build output
behavior -> executed user journey and observed result
performance -> equivalent baseline and candidate profiles
quality -> types, lint, dependency checks and relevant tests
intended_flow -> statechart compared with exercised behavior
acceptance -> team review against the requested product outcome
CONTROL profile build, input, workload and cache state
CAPTURE recordings or traces for interaction and timing changes
USE screenshots to document visible states
ASSERT import analysis establishes boundaries, not execution time
ASSERT a recording covers the demonstrated scenario
ASSERT tests establish the properties actually checked
ASSERT skills require available tools and working procedures
}
check.record {
requirement := [ACCEPTANCE_ITEM]
commit := [TESTED_COMMIT]
worktree := [TESTED_DIFF]
environment := [BUILD_AND_REQUIRED_STATE]
execution := [COMMAND_OR_ACTIONS]
expected := [REQUIRED_OBSERVATION]
observed := [ACTUAL_RESULT]
exit_code := [VALUE_IF_APPLICABLE]
artifacts := [EVIDENCE_PATHS]
status := PASS | FAIL | NOT_RUN
blocker := [MISSING_PREREQUISITE_IF_ANY]
}
result.route {
PASS -> retain current evidence and prepare required review
FAIL -> correct the demonstrated cause and rerun affected checks
NOT_RUN -> name the prerequisite, responsible owner and next action
ON code or environment change:
REASSESS prior evidence
RERUN checks whose assumptions or dependencies changed
ASSERT evidence.commit == returned.commit
ASSERT evidence.worktree == returned.worktree
}
repository.maintain {
FIND repeated corrections and obsolete implementation examples
ENCODE stable requirements in APIs or automated checks
MAKE diagnostics identify the violation and supported recovery
VERIFY the constraint catches the original failure
VERIFY permitted behavior still succeeds
MIGRATE obsolete examples
PRESERVE useful design rationale
AVOID unrelated redesign driven by broad model critique
}
return to_thread {
revision := tested commit and worktree state
change := cohesive diff or PR
checks := individual results and execution records
artifacts := screenshots, recordings, logs and traces
limits := uncovered cases, blockers and uncertainty
decisions := unresolved product or release questions
next_action := responsible owner and required action
RETURN the result for the original thread
SEND messages only when that action is authorized
FOLLOW repository review and merge policy
}
autonomy.expand {
REQUIRE repeatable verification before broader delegation
DEFINE permissions, isolation and stop conditions
KEEP a decision log and rollback options
EXPAND only within approved authority
}
This is f*cking gold, the CEO of Obsidian put his own second brain on GitHub for free and people still build theirs from zero
7 free repos from the Obsidian team:
-> kepano obsidian (by kepano) https://t.co/lT5QtPucOn the vault template of the Obsidian CEO himself, copy it and skip the blank page
-> jsoncanvas (by obsidianmd) https://t.co/iNkNYs8Y7k the open canvas format, your maps stay plain files that are yours forever
-> obsidian releases (by obsidianmd) https://t.co/AMjE6dW82S every community plugin and theme in one list
-> obsidian sample plugin (by obsidianmd) https://t.co/Ytp6e1mcDo the official template, build the plugin you are missing
-> 40 questions (by kepano) https://t.co/3BJ35OEFsA 40 questions that turn your notes into a yearly review
-> obsidian minimal (by kepano) https://t.co/idJC0tBWMJ a clean theme so your vault stops looking like a mess
-> flexoki (by kepano) https://t.co/FswpE9XrZ4 the color scheme he made for writing and code
your second brain should never start from a blank page
copy his vault and make it yours
here's how i shipped 2,500 PRs last month to production
this was originally supposed to be for Cursor Compile in London. i couldn't make it since i was livestreaming for Grok @Bot Galaxy so i'm making it available for free here on X! watch it on 2x speed, i talk slowly
This is f*cking insane. SpaceXAI engineer (ex-Cursor):
"99% of people still use GrokBot like a chatbot. Five lazy words, a wrong answer, then an hour of arguing with it
We have thousands of agents running inside SpaceXAI. Every one gets its own computer, checks its own work and sends back the screen recording. That's how we ship this much code"
In this 1-hour workshop, this engineer shows the same task going from 175x the cost to a clean one-shot on Grok 4.6
GrokBot → Planned Shot → Agents With Their Own Computer → Thousands Of Automations → A Company That Ships While You Sleep
A planned shot means the agent knows what done looks like before it writes a single line
A fresh chat per task, because the model forgets everything and rereads your whole mess on every message
Most people keep one chat alive for weeks and blame the model when it gets dumber
Worth more than any $25,000 agentic engineering bootcamp
Bookmark it and watch it tonight
Then read how to set up agents that check their own work in the enhanced edition of the agent engineering guide below ↓