23 every year ♡ ex @SpaceX dev · exploring AI coding with a cat on my lap
Joined June 2024
- Tweets1.3K
- Following74
- Followers705
- Likes10.5K
cranger retweeted
I couldn’t f*cking believe this. I gave Grok Bot two crypto hacks to investigate.
14 minutes later it told me to close a tab I had open.
i almost ignored it. i’d used that site all week.
then it showed me why.
i’d asked three bots to reconstruct the Binance and Polymarket attacks, then check the sites where i actually trade.
one prompt. Scout, Watchdog, Skeptic. running on Grok Bot’s own cloud computer.
i expected a summary of how other people lost their money.
Scout came back with 12 flagged sites.
i recognized the first one immediately.
the second was in my bookmarks.
the third was open next to the report.
holy SH*T.
so i made Skeptic challenge the whole thing.
“assume Scout is wrong. show me what it actually found.”
that’s when the report got interesting.
→ Scout mapped 23 outside scripts loading on the pages where i sign transactions
→ Watchdog compared what those pages loaded between checks
→ Skeptic traced the flagged changes and demanded evidence for every warning
→ another check looked for wallet delegations i didn’t recognize
then one row changed while i was watching.
same website. same familiar interface. a different script underneath.
i opened the comparison. Skeptic was already reviewing it.
i’d refreshed that page all week without once asking what else it was loading.
now i was staring at the answer.
this is the same Grok Bot i’d been using to chase $10,000 on polymarket.
i had given it detailed rules for entering a trade. position limits. exit conditions. everything.
my rule for trusting the website was apparently “i’ve been here before.”
that bothered me more than the red flags.
so i gave the bots a permanent job.
Scout keeps the inventory of sites, scripts and public wallet addresses.
Watchdog checks the baseline every 10 minutes.
Skeptic investigates changes and sends the evidence to my phone.
the alerts show the old version, the new version, and what needs my attention.
at 2:13 a.m., my phone lit up again.
another change. another site i knew.
i read the report before opening the tab.
yesterday i wouldn’t have known anything had changed.
watch the video when the first familiar domain appears in Scout’s results. that’s where this stopped feeling like somebody else’s problem.
the setup:
→ create Scout, Watchdog and Skeptic in Grok Bot
→ give Scout the public addresses and sites you want monitored
→ establish a baseline and schedule Watchdog’s checks
→ make Skeptic attach evidence to every alert
→ route the reports to your phone
i started with “explain these hacks.”
i ended up checking my browser history against the report.
paste the prompt into Grok Bot tonight. start with the site you trust enough to leave open.
exact prompt in the replies. full setup in the article.
I couldn’t f*cking believe this. I gave Grok Bot two crypto hacks to investigate.
14 minutes later it told me to close a tab I had open.
i almost ignored it. i’d used that site all week.
then it showed me why.
i’d asked three bots to reconstruct the Binance and Polymarket attacks, then check the sites where i actually trade.
one prompt. Scout, Watchdog, Skeptic. running on Grok Bot’s own cloud computer.
i expected a summary of how other people lost their money.
Scout came back with 12 flagged sites.
i recognized the first one immediately.
the second was in my bookmarks.
the third was open next to the report.
holy SH*T.
so i made Skeptic challenge the whole thing.
“assume Scout is wrong. show me what it actually found.”
that’s when the report got interesting.
→ Scout mapped 23 outside scripts loading on the pages where i sign transactions
→ Watchdog compared what those pages loaded between checks
→ Skeptic traced the flagged changes and demanded evidence for every warning
→ another check looked for wallet delegations i didn’t recognize
then one row changed while i was watching.
same website. same familiar interface. a different script underneath.
i opened the comparison. Skeptic was already reviewing it.
i’d refreshed that page all week without once asking what else it was loading.
now i was staring at the answer.
this is the same Grok Bot i’d been using to chase $10,000 on polymarket.
i had given it detailed rules for entering a trade. position limits. exit conditions. everything.
my rule for trusting the website was apparently “i’ve been here before.”
that bothered me more than the red flags.
so i gave the bots a permanent job.
Scout keeps the inventory of sites, scripts and public wallet addresses.
Watchdog checks the baseline every 10 minutes.
Skeptic investigates changes and sends the evidence to my phone.
the alerts show the old version, the new version, and what needs my attention.
at 2:13 a.m., my phone lit up again.
another change. another site i knew.
i read the report before opening the tab.
yesterday i wouldn’t have known anything had changed.
watch the video when the first familiar domain appears in Scout’s results. that’s where this stopped feeling like somebody else’s problem.
the setup:
→ create Scout, Watchdog and Skeptic in Grok Bot
→ give Scout the public addresses and sites you want monitored
→ establish a baseline and schedule Watchdog’s checks
→ make Skeptic attach evidence to every alert
→ route the reports to your phone
i started with “explain these hacks.”
i ended up checking my browser history against the report.
paste the prompt into Grok Bot tonight. start with the site you trust enough to leave open.
exact prompt in the replies. full setup in the article.
I gave Grok Bot $5,000 when the Binance hack hit the timeline
94 minutes later it was $6,394.62
+$1,394.62 while I was still reading replies trying to figure out what happened
called it Crisis Mode. one rule: nothing moves until the entry AND the exit are checked
> BNB shorts the selloff on an external venue
> Stables looks for 5–10% price gaps and checks the cost of moving between chains
> ETH targets 10–15% gross spreads between cheaper venues and overpriced pools
> Bridge checks the Polymarket route before sending anything
> Alts watches dumped UNI, PEPE and ENA against prices elsewhere
> TRX looks for the SunSwap premium and an executable exit
the hacker was dumping tokens and rushing into ETH and TRX. the same coins suddenly had different prices depending on where you looked
8 closed trades
6 green, 2 red
the 2 red ones cost $61.25 combined, worst one -$38.40
the Polymarket route never cleared the checks. $0 sent.
best trade used $3,500 to catch an ETH spread for +$525 before execution costs
$5,000 → $5,180 → $5,492.15 → $6,394.62
I kept refreshing the news. it kept checking prices.
would you let a bot trade through a hack, or would you shut everything down?
send this to whoever saw “Binance hacked” and immediately closed every chart
cranger retweeted
THIS IS F*CKING INSANE. A 19-YEAR-OLD COLLEGE STUDENT MADE $6,420 IN JUST 11 SECONDS
he just gave Grok Bot $80 and it started copying. 31 trades out of 11,840 signals. his reaction when he saw the result was impossible to put into words
he opened the trade log expecting to see which wallets made him money
most of the screen was rejected entries
here’s how he configured the bot:
→ WATCHLIST: load the 640 wallets and their trading histories. only purchases from those addresses enter the queue
→ SIGNALS: connect transaction alerts and market data. every candidate needs a source transaction, timestamp, and obtainable price
→ FILTERS: reject thin liquidity, concentrated holders, heavy developer holdings, bundled buys, and tokens that already moved too far
→ RECHECK: look at the source wallet again before copying. if it has started selling, cancel the entry
→ EXECUTION: connect the trading service with a spending cap, position limits, fresh quotes, and exit conditions set before entry
→ RECORD: show every rejection, copied order, actual fill, fee, and exit. replay the workflow before enabling live orders
one screen shows what the bot followed and everything it refused to touch
what got rejected during the session:
→ 3,184 signals: top 10 holders controlled more than 40%
→ 2,671: liquidity below $30K
→ 2,019: developer wallet still held more than 8%
→ 1,847: bundled buying in the first 60 seconds
→ 1,691: price already up 80% in 15 minutes
→ 397: source wallet sold early
11,840 signals. 11,809 rejected. 31 copied
only 0.26% of the feed made it through
account balance: $80 → $214 → $890 → $2,470 → $6,420
the same wallets stayed on watch. new transactions triggered fresh checks, while unchanged token research stayed saved
save this. study what the bot skipped before copying what it bought
the article below shows 7 workflow changes that keep a wallet-watching bot cheaper to run, so every new alert doesn’t trigger another full investigation ↓
THIS IS F*CKING INSANE. A 19-YEAR-OLD COLLEGE STUDENT MADE $6,420 IN JUST 11 SECONDS
he just gave Grok Bot $80 and it started copying. 31 trades out of 11,840 signals. his reaction when he saw the result was impossible to put into words
he opened the trade log expecting to see which wallets made him money
most of the screen was rejected entries
here’s how he configured the bot:
→ WATCHLIST: load the 640 wallets and their trading histories. only purchases from those addresses enter the queue
→ SIGNALS: connect transaction alerts and market data. every candidate needs a source transaction, timestamp, and obtainable price
→ FILTERS: reject thin liquidity, concentrated holders, heavy developer holdings, bundled buys, and tokens that already moved too far
→ RECHECK: look at the source wallet again before copying. if it has started selling, cancel the entry
→ EXECUTION: connect the trading service with a spending cap, position limits, fresh quotes, and exit conditions set before entry
→ RECORD: show every rejection, copied order, actual fill, fee, and exit. replay the workflow before enabling live orders
one screen shows what the bot followed and everything it refused to touch
what got rejected during the session:
→ 3,184 signals: top 10 holders controlled more than 40%
→ 2,671: liquidity below $30K
→ 2,019: developer wallet still held more than 8%
→ 1,847: bundled buying in the first 60 seconds
→ 1,691: price already up 80% in 15 minutes
→ 397: source wallet sold early
11,840 signals. 11,809 rejected. 31 copied
only 0.26% of the feed made it through
account balance: $80 → $214 → $890 → $2,470 → $6,420
the same wallets stayed on watch. new transactions triggered fresh checks, while unchanged token research stayed saved
save this. study what the bot skipped before copying what it bought
the article below shows 7 workflow changes that keep a wallet-watching bot cheaper to run, so every new alert doesn’t trigger another full investigation ↓
cranger retweeted
THIS IS PURE F*CKING TREASURE
Grok Bot's docs describe Bots handing work to a specialist. This free audit setup gives every scary-looking finding a second check before it reaches your report.
The idea: separate the Bot that spots a possible bug from the Bot that tries to reproduce it.
Three confident guesses shouldn't become three urgent fixes. Make each one earn its place with a file reference, a failing case and a reason it matters.
You just give Grok Bot this setup:
Scan the diff. Challenge every finding. Return the ones that survive.
here's the split:
→ scan reads the changed lines and proposes candidate findings
→ trace checks callers, contracts and the surrounding code
→ reproduce tries the smallest safe case against the current revision
→ Reviewer separates confirmed blockers, dismissed guesses and open questions
Reviewer only steps in at three moments:
→ before the audit scope is locked
→ when the evidence contradicts a candidate finding
→ before the final report goes back to Builder
Scan proposals. Evidence decides. Reviewer filters.
Explicit routing is the same move one layer down: a stale fixture goes back for correction, a reproducible failure moves forward, and missing evidence stays an open question.
the full tree
> Builder supplies the proposed diff and exact revision
> scan returns candidates with changed-file references
> trace checks whether each candidate fits the real call path
> reproduce checks each claim in a disposable test copy
> Reviewer records confirmed, dismissed and unresolved items separately
> Builder receives one evidence-backed audit before deciding what to edit
paste the tree and this prompt into Grok Bot ↓
"Set up a scoped audit around this tree:
1. Ask for the repo, base revision and proposed diff. Draft scan, trace, reproduce and Reviewer roles. Keep the source checkout read-only.
2. Have scan propose candidates with file references. Have trace inspect the relevant callers and contracts. Give reproduce the current revision and a disposable copy for safe local tests.
3. Require an independent check for every candidate. Record the test, expected behavior, observed behavior and revision. Dismiss claims contradicted by evidence. Keep untested claims as questions.
4. Return confirmed blockers, dismissed candidates and unresolved questions separately. Do not treat a clean report as proof that the patch has no bugs. Show the proposed roster and test plan first. No Bot creation, test execution, configuration changes, edits, merges or publishing until I say go."
↳ docs.x.ai/grok-bot/chat-and-…
save it, your next code review needs fewer guesses.
THIS IS PURE F*CKING TREASURE
Grok Bot's docs describe Bots handing work to a specialist. This free audit setup gives every scary-looking finding a second check before it reaches your report.
The idea: separate the Bot that spots a possible bug from the Bot that tries to reproduce it.
Three confident guesses shouldn't become three urgent fixes. Make each one earn its place with a file reference, a failing case and a reason it matters.
You just give Grok Bot this setup:
Scan the diff. Challenge every finding. Return the ones that survive.
here's the split:
→ scan reads the changed lines and proposes candidate findings
→ trace checks callers, contracts and the surrounding code
→ reproduce tries the smallest safe case against the current revision
→ Reviewer separates confirmed blockers, dismissed guesses and open questions
Reviewer only steps in at three moments:
→ before the audit scope is locked
→ when the evidence contradicts a candidate finding
→ before the final report goes back to Builder
Scan proposals. Evidence decides. Reviewer filters.
Explicit routing is the same move one layer down: a stale fixture goes back for correction, a reproducible failure moves forward, and missing evidence stays an open question.
the full tree
> Builder supplies the proposed diff and exact revision
> scan returns candidates with changed-file references
> trace checks whether each candidate fits the real call path
> reproduce checks each claim in a disposable test copy
> Reviewer records confirmed, dismissed and unresolved items separately
> Builder receives one evidence-backed audit before deciding what to edit
paste the tree and this prompt into Grok Bot ↓
"Set up a scoped audit around this tree:
1. Ask for the repo, base revision and proposed diff. Draft scan, trace, reproduce and Reviewer roles. Keep the source checkout read-only.
2. Have scan propose candidates with file references. Have trace inspect the relevant callers and contracts. Give reproduce the current revision and a disposable copy for safe local tests.
3. Require an independent check for every candidate. Record the test, expected behavior, observed behavior and revision. Dismiss claims contradicted by evidence. Keep untested claims as questions.
4. Return confirmed blockers, dismissed candidates and unresolved questions separately. Do not treat a clean report as proof that the patch has no bugs. Show the proposed roster and test plan first. No Bot creation, test execution, configuration changes, edits, merges or publishing until I say go."
↳ docs.x.ai/grok-bot/chat-and-…
save it, your next code review needs fewer guesses.
cranger retweeted
THIS IS ACTUAL F*CKING GOLD
Grok Bot can hand work between Bots. This free workflow stops you being the copy-paste layer between every agent.
The idea: let Builder write the plan once, then pass a clear task, current artifact and definition of done with every handoff.
Bigger jobs become easier to follow because the next Bot gets a complete work order instead of a vague "continue from here."
You just give Grok Bot this setup:
Builder owns the workflow. Scouts return evidence. Reviewer checks the final handoff.
here's the split:
→ Builder turns your objective into ordered tasks and writes the patch
→ Scout Bots scan the relevant files, check docs and verify the changes
→ Reviewer checks the plan and the verified diff at decision points
→ you stop relaying every partial result between conversations
Reviewer only steps in at three moments:
→ before tasks are dispatched
→ when a handoff is blocked or contradicts the plan
→ before Builder calls the whole job done
Builder plans. Scouts investigate. Reviewer signs off.
Explicit routing is the same move one layer down: completed prerequisites unlock the next step, while missing inputs go back to the owner as a concrete question.
the full tree
> Builder writes the plan and owns the proposed patch
> scan maps the touched files and returns references
> docs checks the API contracts that constrain the change
> verify checks the latest patch and returns evidence
> Reviewer sees the plan, current diff and unresolved blockers
> Builder returns one consolidated result after review
paste the tree and this prompt into Grok Bot ↓
"Rebuild my Grok Bot workflow around this tree:
1. Draft an ordered task list with one owner, required inputs and a definition of done for each step. Propose Builder, scan, docs, verify and Reviewer roles.
2. Keep scan and docs read-only. Have them return file references and contract notes to Builder. Builder owns implementation; verify checks the current patch and reports evidence.
3. Every handoff must include the task ID, current artifact or revision, completed work and remaining blocker. A missing input becomes a question for the owner. Never mark a blocked step complete.
4. Consult Reviewer before dispatch, when a handoff conflicts with the plan, and before final completion. Return one consolidated diff with verification results. Show the proposed setup first. No Bot creation, configuration changes, edits, merges or publishing until I say go."
↳ docs.x.ai/grok-bot/chat-and-…
save it, you'll want this before your next multi-Bot task.
cranger retweeted
HOLY SH*T. i built my first Grok Bot trading terminal. THANKS ELON
i started by reverse engineering the public trade history behind a Polymarket account showing +$677,154.
one question kept bothering me: what was actually happening behind that curve?
one lucky bet? thousands of tiny trades? buying outcomes everyone else had given up on?
i pulled the public history. the answer was more interesting than the screenshot.
→ 11,810 trade records
→ 1,673 markets with trading activity
→ 2,391 MERGE operations
→ both outcomes bought in 704 markets
BTC and ETH were the main focus. there were oil markets too.
why this caught my attention:
→ the price data is public
→ every market has a specific settlement rule
→ you can inspect entries, inventory and payouts instead of guessing from a green chart
three patterns stood out:
1. building positions in pieces
the biggest ETH position was almost 693,000 YES shares on ETH touching $2,250 before the end of 2026.
275 buys. an average entry around 34¢. valued around 78¢ in the saved snapshot.
but the first entries were around 75¢. the low average came later, after much cheaper buys.
2. buying both sides
one YES + one NO in the same binary market can be merged back into $1 of collateral.
if the complete pair costs less than $1 after costs, the difference is locked in once both sides are filled.
that last part matters. this trader sometimes bought the second side much later. there was risk between the fills.
3. keeping large directional exposure
YES on lower ETH levels. NO on ETH reaching $3,500. NO on BTC touching $50,000 and $55,000.
these are different contracts, with different deadlines and prices. copying the labels today would not recreate those entries.
honest part: the $677k headline is trading PnL before fees, including open-position gains. it is not a cash-out receipt. the largest position alone represented about 57% of the displayed portfolio value.
the public history doesn't reveal the trader's probability model. that's the part i'd test before putting a bot anywhere near real money.
the next step i'd build: Grok agents running 24/7, scanning BTC and ETH markets, checking prices and liquidity, finding potential entry points and placing paper trades. live execution would stay behind a manual approval gate until the strategy had been tested.
here's the team i'd connect to the Grok Bot desk:
→ Scout continuously scans markets and reads their rules, price sources, deadlines and order books
→ Trader looks for entry points where estimated probability exceeds the executable price after costs, places paper trades and tracks both sides separately
→ Risk checks concentration, liquidity and what happens if only one side fills
→ Builder turns the research into a terminal with a paper-trading log and a manual live-trading gate
start with this prompt:
“Help me design a Polymarket research and paper-trading desk for BTC and ETH, with Grok agents named Scout, Trader, Risk and Builder. Design continuous market scanning, entry-point detection and paper execution with monitoring and restart handling. Separate touch markets from closing-price markets. Read the settlement rules before choosing a price feed. Make every probability estimate explain its assumptions. Include fees, slippage and partial fills. Track complete-set costs and unmatched exposure. Show realized and unrealized PnL separately. Keep live trading disabled.”
the terminal below replays the public PnL history and shows how i'd organize that workflow.
save the prompt. start by checking one market properly ↓
THIS IS ACTUAL F*CKING GOLD
Grok Bot can hand work between Bots. This free workflow stops you being the copy-paste layer between every agent.
The idea: let Builder write the plan once, then pass a clear task, current artifact and definition of done with every handoff.
Bigger jobs become easier to follow because the next Bot gets a complete work order instead of a vague "continue from here."
You just give Grok Bot this setup:
Builder owns the workflow. Scouts return evidence. Reviewer checks the final handoff.
here's the split:
→ Builder turns your objective into ordered tasks and writes the patch
→ Scout Bots scan the relevant files, check docs and verify the changes
→ Reviewer checks the plan and the verified diff at decision points
→ you stop relaying every partial result between conversations
Reviewer only steps in at three moments:
→ before tasks are dispatched
→ when a handoff is blocked or contradicts the plan
→ before Builder calls the whole job done
Builder plans. Scouts investigate. Reviewer signs off.
Explicit routing is the same move one layer down: completed prerequisites unlock the next step, while missing inputs go back to the owner as a concrete question.
the full tree
> Builder writes the plan and owns the proposed patch
> scan maps the touched files and returns references
> docs checks the API contracts that constrain the change
> verify checks the latest patch and returns evidence
> Reviewer sees the plan, current diff and unresolved blockers
> Builder returns one consolidated result after review
paste the tree and this prompt into Grok Bot ↓
"Rebuild my Grok Bot workflow around this tree:
1. Draft an ordered task list with one owner, required inputs and a definition of done for each step. Propose Builder, scan, docs, verify and Reviewer roles.
2. Keep scan and docs read-only. Have them return file references and contract notes to Builder. Builder owns implementation; verify checks the current patch and reports evidence.
3. Every handoff must include the task ID, current artifact or revision, completed work and remaining blocker. A missing input becomes a question for the owner. Never mark a blocked step complete.
4. Consult Reviewer before dispatch, when a handoff conflicts with the plan, and before final completion. Return one consolidated diff with verification results. Show the proposed setup first. No Bot creation, configuration changes, edits, merges or publishing until I say go."
↳ docs.x.ai/grok-bot/chat-and-…
save it, you'll want this before your next multi-Bot task.
cranger retweeted
THIS IS PURE F*CKING TREASURE
Grok Bot supports reusable skills. This free PR-review blueprint gives your Bots the playbook you keep typing from scratch.
The idea: save the review process once, then reference that skill when the next diff lands.
Your checklist stops getting buried halfway up an old conversation, and the next review starts with the same rules.
You just give Grok Bot this setup:
Save a skill called PR Review. Include the inputs, review steps, evidence format and approval boundary.
here's the split:
→ inputs define the repo, base revision and proposed diff
→ rules explain which contracts and edge cases to inspect
→ checks define the evidence every finding must include
→ you stop rebuilding the review instructions for every new task
Three lines do the heavy lifting:
→ when to use it: a proposed code change needs review
→ what to return: blocking findings with file references and a clear reason
→ when to stop: a required input is missing or an action needs approval
Inputs arrive. Rules guide. Checks verify.
Explicit routing is the same move one layer down: known steps follow the saved playbook, and ambiguous cases go back to the Bot that owns the decision.
the full tree
> PR Review holds the reusable method
> inputs Scout identifies the repo, base revision and diff
> rules Scout checks contracts, failure paths and edge cases
> checks Scout attaches evidence to each proposed finding
> Reviewer checks the skill before it is saved or revised
> Builder applies the playbook and returns the review
paste the tree and this prompt into Grok Bot ↓
"Build my PR Review skill around this tree:
1. Draft one reusable skill with a trigger, required inputs, review steps, output format and approval boundary.
2. Require the repo, base revision and proposed diff. If anything is missing, ask for it before reviewing.
3. Return blocking findings with file references, reasons and evidence. Separate confirmed issues from questions. Use the read-only review roles inputs, rules and checks to inspect the draft and return concise handoffs.
4. Have Reviewer inspect the skill, then show me the complete text. Save it only after I approve. Reference the approved skill for later reviews; ask before changing its rules. Do not edit source files, merge or publish."
↳ docs.x.ai/grok-bot/skills-ro…
save it, you'll use this on the next diff.
THIS IS PURE F*CKING TREASURE
Grok Bot supports reusable skills. This free PR-review blueprint gives your Bots the playbook you keep typing from scratch.
The idea: save the review process once, then reference that skill when the next diff lands.
Your checklist stops getting buried halfway up an old conversation, and the next review starts with the same rules.
You just give Grok Bot this setup:
Save a skill called PR Review. Include the inputs, review steps, evidence format and approval boundary.
here's the split:
→ inputs define the repo, base revision and proposed diff
→ rules explain which contracts and edge cases to inspect
→ checks define the evidence every finding must include
→ you stop rebuilding the review instructions for every new task
Three lines do the heavy lifting:
→ when to use it: a proposed code change needs review
→ what to return: blocking findings with file references and a clear reason
→ when to stop: a required input is missing or an action needs approval
Inputs arrive. Rules guide. Checks verify.
Explicit routing is the same move one layer down: known steps follow the saved playbook, and ambiguous cases go back to the Bot that owns the decision.
the full tree
> PR Review holds the reusable method
> inputs Scout identifies the repo, base revision and diff
> rules Scout checks contracts, failure paths and edge cases
> checks Scout attaches evidence to each proposed finding
> Reviewer checks the skill before it is saved or revised
> Builder applies the playbook and returns the review
paste the tree and this prompt into Grok Bot ↓
"Build my PR Review skill around this tree:
1. Draft one reusable skill with a trigger, required inputs, review steps, output format and approval boundary.
2. Require the repo, base revision and proposed diff. If anything is missing, ask for it before reviewing.
3. Return blocking findings with file references, reasons and evidence. Separate confirmed issues from questions. Use the read-only review roles inputs, rules and checks to inspect the draft and return concise handoffs.
4. Have Reviewer inspect the skill, then show me the complete text. Save it only after I approve. Reference the approved skill for later reviews; ask before changing its rules. Do not edit source files, merge or publish."
↳ docs.x.ai/grok-bot/skills-ro…
save it, you'll use this on the next diff.
cranger retweeted
holy f*ck. This free Grok Bot workshop shows how one person runs an AI team.
"I have a bot for each person that I would work with normally."
In this 53-minute session, Krista walks through her Chief of Staff, engineer bot, customer experts, X bot, and slide designer.
Grok Bot → Chief of Staff → X research → Slide designer → Deck
Her Chief of Staff hands research tasks to the X bot, then brings in a designer with her brand guidelines.
A customer bot remembers feature requests and brings back a draft email when the feature ships.
Watch this before paying for another agent course.
Bookmark it and watch today.
Then use the setup checklist in the first reply to build your own team ↓
cranger retweeted
THIS IS ACTUAL F*CKING GOLD
Grok Bot's own docs describe Bots handing work to each other. Here's the coding setup I'd build around that.
The idea: run Builder, Scout and Reviewer roles together, each one doing only the job it's best at.
Reviewer-level judgment on every big call, without pulling the Reviewer into every routine turn.
You just start the Grok Bot team like this:
Builder own the code. Scouts handle lookup. Reviewer stay on call for the big decisions.
here's the split:
→ Builder runs the coding task and writes the changes
→ Scout Bots explore files, call sites and the draft diff in parallel
→ Reviewer stays on call as advisor for the big calls
→ you stop flooding the lead thread with every lookup transcript
Reviewer only steps in at three moments:
→ before a plan locks
→ when the same error shows up twice
→ before calling it done
Builder builds. Scouts explore. Reviewer reviews.
Tool routing is the same move one layer down: the forks that need no new judgment follow explicit rules, and the Bots see the ones that need a decision.
the full tree
> Builder owns the coding task and edits the source
> search maps the repo as a Scout Bot
> grep finds call sites as a Scout Bot
> audit checks the proposed diff in a scratch copy as a Scout Bot
> Reviewer stays on call and reads the shared handoff when consulted
> explicit routing rules cover file choice, tool choice and when to ask
paste the tree and this prompt into Grok Bot ↓
"Rebuild my Grok Bot coding setup around this tree:
1. Give Builder ownership of implementation and Reviewer ownership of strategic review.
2. Propose three Scout Bots: search maps the repo, grep finds call sites, and audit checks the proposed diff. Assign each a clear output and return concise findings with file references.
3. Add one operating rule: consult Reviewer before locking a plan, after the same error twice, and before calling a task done. Include the plan, latest diff, evidence and unresolved questions in the handoff.
4. Keep mechanical routing in explicit rules. Use a separate scratch copy for audit checks and return findings to Builder. Show the proposed roster and every configuration or file change as a diff first. No edits or Bot creation until I say go."
↳ docs.x.ai/grok-bot/chat-and-…
save it, you'll use this every single day.
THIS IS ACTUAL F*CKING GOLD
Grok Bot's own docs describe Bots handing work to each other. Here's the coding setup I'd build around that.
The idea: run Builder, Scout and Reviewer roles together, each one doing only the job it's best at.
Reviewer-level judgment on every big call, without pulling the Reviewer into every routine turn.
You just start the Grok Bot team like this:
Builder own the code. Scouts handle lookup. Reviewer stay on call for the big decisions.
here's the split:
→ Builder runs the coding task and writes the changes
→ Scout Bots explore files, call sites and the draft diff in parallel
→ Reviewer stays on call as advisor for the big calls
→ you stop flooding the lead thread with every lookup transcript
Reviewer only steps in at three moments:
→ before a plan locks
→ when the same error shows up twice
→ before calling it done
Builder builds. Scouts explore. Reviewer reviews.
Tool routing is the same move one layer down: the forks that need no new judgment follow explicit rules, and the Bots see the ones that need a decision.
the full tree
> Builder owns the coding task and edits the source
> search maps the repo as a Scout Bot
> grep finds call sites as a Scout Bot
> audit checks the proposed diff in a scratch copy as a Scout Bot
> Reviewer stays on call and reads the shared handoff when consulted
> explicit routing rules cover file choice, tool choice and when to ask
paste the tree and this prompt into Grok Bot ↓
"Rebuild my Grok Bot coding setup around this tree:
1. Give Builder ownership of implementation and Reviewer ownership of strategic review.
2. Propose three Scout Bots: search maps the repo, grep finds call sites, and audit checks the proposed diff. Assign each a clear output and return concise findings with file references.
3. Add one operating rule: consult Reviewer before locking a plan, after the same error twice, and before calling a task done. Include the plan, latest diff, evidence and unresolved questions in the handoff.
4. Keep mechanical routing in explicit rules. Use a separate scratch copy for audit checks and return findings to Builder. Show the proposed roster and every configuration or file change as a diff first. No edits or Bot creation until I say go."
↳ docs.x.ai/grok-bot/chat-and-…
save it, you'll use this every single day.
cranger retweeted
Gemini vs Opus 5.5 vs ChatGPT 6 vs Grok
same brief: a Trojan horse in Blender
> Gemini $4.87
> Opus $4.94
> ChatGPT $4.96
> Grok $4.99
all look decent, but imo Grok wins on detail and atmosphere
full prompt in the reply ↓
Gemini vs Opus 5.5 vs ChatGPT 6 vs Grok
same brief: a Trojan horse in Blender
> Gemini $4.87
> Opus $4.94
> ChatGPT $4.96
> Grok $4.99
all look decent, but imo Grok wins on detail and atmosphere
full prompt in the reply ↓
Create a detailed cinematic Trojan horse model in Blender, inspired by the monumental scale and dark atmosphere of The Odyssey.
Build an enormous wooden horse rearing on its hind legs, with an arched neck, defined muzzle, pointed ears, broad chest and two bent front legs. Keep the silhouette elegant and recognisable.
Construct the body from overlapping horizontal wooden planks that follow its curves. Give each plank thickness, beveled edges, visible grain, narrow gaps and subtle weathering. Use varied dark oak and walnut tones.
Include a believable internal framework of curved ribs, crossbeams and diagonal braces. Add bronze rivets, dark iron straps, reinforced joints, a discreet side hatch and an aged bronze bridle. Build the mane from short wooden ridges and the tail from curved timber sections.
Mount the horse on a heavy rectangular timber platform with visible axles and four large spoked wooden wheels with iron rims. Make all supports and connections structurally convincing.
Place it outside Troy’s massive stone gates beside the sea. Surround it with canvas tents, shield racks, spears, amphorae, stacked timber, coiled ropes, wooden scaffolding and burning torches. Add several ancient Greek ships with dark red square sails along the shoreline. Include a few bronze-armored guards to establish scale.
Set the scene at stormy dusk, with blue-grey clouds, cool ambient light, warm firelight and restrained smoke. Use realistic wood, aged metal and rough stone materials, with clear contact shadows.
Compose a low front three-quarter view. Keep the entire horse visible, its head against the sky, with the gate behind it and ships to one side. Aim for the weight and atmosphere of a practical film set.
Create a static scene only. No animation, text, logos or interface elements.
Deliver an editable .blend file with packed textures and one high-quality 1920×1080 still render. Check for floating props, intersecting geometry and missing materials.
cranger retweeted
there is no way this is real
tested 4 models in Blender and honestly the results blew me away
gave them all the same prompt: build a Disney-style castle and spend no more than $5. each model took that a little differently
> Gemini: $3.00
> Opus 5.5: $4.00
> ChatGPT 6: $4.50
> Grok: $5.00
i'll let you pick the winner. these surprised me
dropped the prompt in the reply ↓