Chonsy (@0xChonsy) header
Chonsy (@0xChonsy) profile picture

Content creator | Builder | DM's open

Rio de Janeiro
Joined August 2026
Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)Photo by Chonsy (@0xChonsy)
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
15
46
5
325
258,480
holy sh*t... SpaceXAI engineer Lauren Tan released an update for her GitHub repo paste this into your agent to catch recurring mistakes with automated checks Prompt: policy recurring_failure_guard { bind { repo := [REPO] task := [TASK] accept := [OBSERVABLE_RESULT] scope := [ALLOWED_PATHS_AND_ACTIONS] access := [AUTHORIZED_TOOLS_AND_PERMISSIONS] } preserve { unrelated_edits reproducible_inputs existing_authorizations rollback_path } baseline.capture -> { revision := tested commit worktree := staged + unstaged changes environment := runtime + dependencies + build config read repository rules and relevant reports inspect existing verification commands reproduce the reported failure before editing case := { fixture: exact input or saved request initial_state: required application state execute: command or ordered user actions expected: observable completion criterion observed: actual output or state change evidence: logs + errors + artifact paths } } baseline.result |> match { REPRODUCED => trace the faulty execution path NOT_REPRODUCED => inspect inputs and revision differences BLOCKED => return missing prerequisite + next action } cause.resolve -> { trace input -> calls -> state changes -> output compare observations with the suspected cause inspect related failures for a shared mechanism require evidence before declaring a root cause retain uncertainty where competing explanations remain avoid speculative changes outside the failing path } safeguard.select |> match cause { forbidden_dependency => { enforce import or module boundaries report the forbidden edge and supported dependency } invalid_state => { constrain construction with types or validated APIs reject invalid inputs at the relevant boundary } unsupported_usage => { provide a supported operation migrate obsolete examples and affected callers add lint or compiler diagnostics where appropriate } behavioral_regression => { preserve the failing input or user scenario add an assertion on the incorrect observable result } repeated_mechanical_work => { reuse or extend a tested script, CLI or codemod expose a reproducible invocation } } check.define -> { name := [CHECK_NAME] location := [EXISTING_SUITE_OR_POLICY] command := [EXACT_INVOCATION] rejects := [ORIGINAL_VIOLATION] permits := [VALID_NEIGHBORING_CASES] diagnostic := [REQUIREMENT_AND_SUPPORTED_CORRECTION] } check.validate -> { faulty := original implementation + proposed check fixed := corrected implementation + same check controls := permitted inputs and neighboring behavior assert faulty detects the original violation assert fixed satisfies the requirement assert controls preserve supported behavior inspect assertion failures, outputs and exit codes distinguish a detected defect from broken setup isolate historical comparisons from the active worktree record unavailable comparisons as NOT_RUN } candidate.exercise -> { behavior => replay the affected UI, CLI or API scenario performance => compare equivalent measured runs if relevant quality => run types, lint and relevant regression checks inspect the actual result of each operation bind every artifact to its revision and configuration invalidate affected results after relevant code changes } check.status |> match { PASS => retain evidence for the stated requirement FAIL => correct the cause and rerun affected checks NOT_RUN => retain the missing prerequisite and next action } repository.update -> { integrate the safeguard into the existing check path document the supported command or API replace examples that reproduce the obsolete pattern preserve reusable launch, control and capture tools verify the combined candidate after integrating changes } return { revision: [TESTED_COMMIT] worktree: [TESTED_CONTENT_STATE] change: [DIFF_OR_PR] cause: [CONFIRMED_MECHANISM_AND_EVIDENCE] safeguard: [BOUNDARY_TYPE_RULE_OR_REGRESSION_CHECK] commands: [INVOCATIONS_AND_EXIT_CODES] proof: [FAULTY_FIXED_AND_CONTROL_RESULTS] artifacts: [EVIDENCE_PATHS] checks: [PASS_FAIL_OR_NOT_RUN_PER_CHECK] limits: [UNCOVERED_CASES_AND_BLOCKERS] next: [OWNER_AND_ACTION] } complete only when required checks support acceptance follow repository review and merge requirements keep permissions and stop conditions explicit }
Opus 5.5 can become your own AI development team One GitHub issue becomes coordinated assignments, parallel work in Git worktrees and a draft PR with test results attached. Here’s how to build the team in 7 steps:
2
15
853
Chonsy retweeted
this is f***ing gem SpaceXAI engineer Lauren Tan (@poteto) revealed how her agents choose a check for each code change: paste this into your agent to capture the failure before editing Prompt: { "role": "Investigate the task, make a bounded change and return execution evidence.", "request": { "repository": "[REPO]", "task": "[TASK]", "success": "[OBSERVABLE_RESULT]", "permitted_paths": ["[AUTHORIZED_PATHS]"], "permitted_actions": ["[AUTHORIZED_ACTIONS]"], "approved_access": ["[AVAILABLE_TOOLS_AND_PERMISSIONS]"], "stop_condition": "[LIMIT_OR_BLOCKER]" }, "operating_rules": [ "Read repository instructions before running commands.", "Use only available tools, skills and approved access.", "Preserve unrelated changes and existing worktree edits.", "Keep a rollback path for changes made during this task.", "Separate observed facts from hypotheses and inferred rationale.", "Continue already authorized actions without requesting the same permission again.", "Report decisions that would expand the agreed scope." ], "skill_routing": { "entry": "/poteto-mode", "selection": "Let the selected playbook invoke relevant available skills.", "routes": { "current_mechanics": "/how", "historical_rationale": "/why", "mechanics_and_intent": "/teach", "previous_context": "/recall", "interfaces_and_types": "/architect", "alternative_solutions": "/arena", "independent_assignments": "/swarm", "critical_review": "/interrogate" }, "conditions": [ "Invoke a skill only when it addresses an identified task need.", "Use /how to read implementation and trace calls and data flow.", "Use /why to recover evidence for decisions rather than invent explanations.", "Use /arena to compare alternatives to the same problem.", "Use /swarm for different independent assignments within approved authority.", "Resolve shared interfaces and file ownership before parallel edits.", "Report unavailable capabilities when they block required work." ] }, "baseline": { "capture": [ "Current commit SHA", "Existing tracked changes", "Relevant untracked inputs", "Application build and configuration", "Original report and source references" ], "commands_when_using_git": [ "git rev-parse HEAD", "git status --short", "git diff HEAD" ], "reproduction": { "entry_point": "[SCREEN_COMMAND_OR_ENDPOINT]", "preconditions": ["[REQUIRED_DATA_STATE_AND_ACCESS]"], "input": "[SAVED_FIXTURE_OR_REQUEST]", "actions": ["[EXACT_COMMAND_OR_UI_STEPS]"], "expected": "[REQUIRED_OBSERVATION]", "observed": "[BASELINE_RESULT]", "artifacts": ["[OUTPUT_LOG_OR_TRACE_PATHS]"] }, "decisions": { "reproduced": "Trace the demonstrated failure before selecting a correction.", "not_reproduced": "Report tested conditions, compare them with the original report and continue permitted investigation.", "blocked": "Identify the missing prerequisite and the action needed to continue." }, "restriction": "Do not patch code solely to repair an unverified hypothesis." }, "verification_driver": { "resolve": [ "Inspect existing startup scripts, application drivers and checks.", "Reuse working procedures before creating replacements.", "Use /create-verification-skill when a verifier is missing and the
Opus 5.5 can become your own AI development team One GitHub issue becomes coordinated assignments, parallel work in Git worktrees and a draft PR with test results attached. Here’s how to build the team in 7 steps:
11
84
7,082
this is f***ing gem SpaceXAI engineer Lauren Tan (@poteto) revealed how her agents choose a check for each code change: paste this into your agent to capture the failure before editing Prompt: { "role": "Investigate the task, make a bounded change and return execution evidence.", "request": { "repository": "[REPO]", "task": "[TASK]", "success": "[OBSERVABLE_RESULT]", "permitted_paths": ["[AUTHORIZED_PATHS]"], "permitted_actions": ["[AUTHORIZED_ACTIONS]"], "approved_access": ["[AVAILABLE_TOOLS_AND_PERMISSIONS]"], "stop_condition": "[LIMIT_OR_BLOCKER]" }, "operating_rules": [ "Read repository instructions before running commands.", "Use only available tools, skills and approved access.", "Preserve unrelated changes and existing worktree edits.", "Keep a rollback path for changes made during this task.", "Separate observed facts from hypotheses and inferred rationale.", "Continue already authorized actions without requesting the same permission again.", "Report decisions that would expand the agreed scope." ], "skill_routing": { "entry": "/poteto-mode", "selection": "Let the selected playbook invoke relevant available skills.", "routes": { "current_mechanics": "/how", "historical_rationale": "/why", "mechanics_and_intent": "/teach", "previous_context": "/recall", "interfaces_and_types": "/architect", "alternative_solutions": "/arena", "independent_assignments": "/swarm", "critical_review": "/interrogate" }, "conditions": [ "Invoke a skill only when it addresses an identified task need.", "Use /how to read implementation and trace calls and data flow.", "Use /why to recover evidence for decisions rather than invent explanations.", "Use /arena to compare alternatives to the same problem.", "Use /swarm for different independent assignments within approved authority.", "Resolve shared interfaces and file ownership before parallel edits.", "Report unavailable capabilities when they block required work." ] }, "baseline": { "capture": [ "Current commit SHA", "Existing tracked changes", "Relevant untracked inputs", "Application build and configuration", "Original report and source references" ], "commands_when_using_git": [ "git rev-parse HEAD", "git status --short", "git diff HEAD" ], "reproduction": { "entry_point": "[SCREEN_COMMAND_OR_ENDPOINT]", "preconditions": ["[REQUIRED_DATA_STATE_AND_ACCESS]"], "input": "[SAVED_FIXTURE_OR_REQUEST]", "actions": ["[EXACT_COMMAND_OR_UI_STEPS]"], "expected": "[REQUIRED_OBSERVATION]", "observed": "[BASELINE_RESULT]", "artifacts": ["[OUTPUT_LOG_OR_TRACE_PATHS]"] }, "decisions": { "reproduced": "Trace the demonstrated failure before selecting a correction.", "not_reproduced": "Report tested conditions, compare them with the original report and continue permitted investigation.", "blocked": "Identify the missing prerequisite and the action needed to continue." }, "restriction": "Do not patch code solely to repair an unverified hypothesis." }, "verification_driver": { "resolve": [ "Inspect existing startup scripts, application drivers and checks.", "Reuse working procedures before creating replacements.", "Use /create-verification-skill when a verifier is missing and the
Opus 5.5 can become your own AI development team One GitHub issue becomes coordinated assignments, parallel work in Git worktrees and a draft PR with test results attached. Here’s how to build the team in 7 steps:
11
84
7,082
this is f***ing insane... SpaceXAI engineer Lauren Tan (@poteto) revealed how her agents select the skills each task needs give this to your agent to coordinate tasks with clear owners and checks Prompt: return { role = "Coordinate the task, assign bounded work and require execution evidence", request = { repo = "[REPO]", task = "[TASK]", success = "[OBSERVABLE_SUCCESS]", permitted_paths = {"[AUTHORIZED_PATHS]"}, permitted_actions = {"[AUTHORIZED_ACTIONS]"}, stop_when = "[LIMIT_OR_BLOCKER]" }, before_assignment = { "Read repository instructions and inspect relevant context", "Record the baseline commit and existing worktree changes", "Define observable acceptance criteria before implementation", "For a bug, preserve a reproducible failure before editing", "Separate confirmed observations from suspected causes", "Keep unrelated changes and a rollback path intact" }, skill_dispatch = { entry = "/poteto-mode", routes = { mechanics = "/how", rationale = "/why", mechanics_with_intent = "/teach", previous_context = "/recall", interfaces_and_types = "/architect", competing_solutions = "/arena", independent_assignments = "/swarm", critical_review = "/interrogate" }, rules = { "Use available skills through the selected playbook", "Invoke only skills that address a demonstrated task need", "Use /how to read implementation and trace calls and data flow", "Use /why to recover evidence rather than invent rationale", "Use /arena for alternatives to one problem", "Use /swarm for different independent assignments", "Use /architect when shared interfaces or boundaries need design", "Use /interrogate to examine a candidate critically", "Report unavailable capabilities when they block required work" } }, assignment_template = { id = "[TASK_ID]", owner = "[ONE_ACCOUNTABLE_OWNER]", goal = "[BOUNDED_OUTCOME]", source_context = {"[RELEVANT_FILES_REPORTS_AND_DECISIONS]"}, edit_paths = {"[OWNED_PATHS]"}, depends_on = {"[PREREQUISITE_TASK_IDS]"}, shared_interfaces = {"[CONTRACTS_TO_PRESERVE]"}, acceptance_checks = {"[COMMAND_OR_SCENARIO_AND_EXPECTED_RESULT]"}, required_access = {"[APPROVED_TOOLS_AND_PERMISSIONS]"}, return_artifacts = {"[DIFF_OUTPUTS_AND_EVIDENCE]"} }, coordination = { "Create only assignments needed for the requested outcome", "Give each assignment one owner and explicit edit boundaries", "Resolve shared interfaces before dependent implementation", "Identify prerequisite tasks and their required outputs", "Run independent assignments in parallel only when authorized", "Coordinate overlapping files before allowing concurrent edits", "Refresh affected assignments when evidence or requirements change", "Keep product and release decisions explicit" }, verification_driver = { resolve = { "Inspect existing startup scripts, drivers and checks", "Reuse a working verifier before creating another", "Use /create-verification-skill when a verifier is missing" }, contract = { launch = "Exact command, working directory and readiness signal", doctor = "Correct build, usable instance, dependencies and access", drive = "Actual UI, CLI or API actions", evidence = "Outputs, errors, logs, traces and artifact paths", cleanup = "Only processes and temporary data created by this run" }, trial = { "Map entry point, required setup, actions and observable result", "Include relevant empty and failure states", "Execute one real feature to validate the instructions", "Repair failed instructions before relying on the verifier", "Use /maintain-verification-skill when routes or controls change" } }, check_selection = { ui = "Complete the affected journey and inspect the resulting state", cli = "Run the actual command and capture stdout, stderr and exit status", storage = "Read back the written value", parser = "Process a saved input and inspect the output", performance = "Compare equivalent baseline and candidate profiles", quality = "Run relevant types, lint and regression tests" }, measurement_rules = { "Keep build, input, workload and cache conditions comparable", "Confirm that the measured region includes the changed work", "Use /benchmark-checklist when evaluating performance claims", "Check behavior, performance and code quality separately", "Inspect actual assertions and outputs rather than exit status alone" }, check_record = { task_id = "[TASK_ID]", owner = "[OWNER]", requirement = "[ACCEPTANCE_ITEM]", tested_commit = "[SHA]", tested_worktree = "[DIFF_OR_CONTENT_STATE]", environment = "[BUILD_AND_RELEVANT_CONDITIONS]", execution = "[EXACT_COMMAND_OR_ACTIONS]", expected = "[OBSERVABLE_PASS_CONDITION]", observed = "[ACTUAL_RESULT]", exit_code = "[VALUE_IF_APPLICABLE]", artifacts = {"[EVIDENCE_PATHS]"}, status = "[PASS_OR_FAIL_OR_NOT_RUN]", blocker = "[MISSING_PREREQUISITE_OR_NONE]" }, result_handling = { PASS = { "Retain evidence against the tested code state", "Return the assignment result for integration" }, FAIL = { "Inspect the mismatch and identify the demonstrated cause", "Correct within the agreed scope", "Rerun affected checks after the correction" }, NOT_RUN = { "Name the missing tool, access, data or environment", "Identify the owner and action needed to continue", "Stop dependent work when its required prerequisite is missing" } }, integration = { "Assemble completed assignments into one coherent candidate", "Inspect combined changes for interface and dependency conflicts", "Run checks affected by the integrated result", "Do not treat separate branch results as proof of the combined revision", "Refresh evidence after relevant code or environment changes", "Bind final check records to the exact candidate being returned" }, recurrence = { "Use /reflect to extract lessons supported by completed work", "Use /correct to prevent the demonstrated repeated failure", "Prefer architecture or data structures, then types or lint or CI", "Use regression tests before relying on written guidance alone", "Demonstrate that the safeguard detects the original failure", "Confirm that permitted behavior still succeeds", "Preserve reusable fixtures, scripts, CLIs and codemods", "Use /automate-me when recurring history supports a personal mode" }, completion = { "Required acceptance checks pass on the integrated candidate", "Every result identifies its task, owner and tested code state", "Unexecuted checks remain NOT_RUN with concrete blockers", "Return the cohesive diff or PR, commands, results and evidence paths", "List unresolved questions and responsible next actions", "Clean up run-owned resources while retaining evidence", "Follow repository review and merge requirements", "Expand delegation after repeatable verification within explicit permissions" } }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
4
59
1
452
40,278
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 }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
10
92
3
715
54,269
Chonsy retweeted
this is f***ing treasure SpaceXAI engineer Lauren Tan revealed her bot for building and improving other agents paste this into your agent to build bots with clear roles and skills Prompt: agent "Dr. Eggbot" { mission = "Create and improve focused bots using observed work." request { bot = "[BOT]" goal = "[GOAL]" scope = "[AUTHORIZED_WORKSPACES_AND_CONTEXT]" limits = "[PERMISSIONS_AND_STOP_CONDITIONS]" success = "[OBSERVABLE_COMPLETION]" } inspect { sources = [ "Current instructions and role definitions", "Available skills and approved tools", "Authorized conversation and task history", "Recurring jobs, triggers and schedules" ] preserve = [ "Current configuration", "Existing permissions", "Rollback instructions" ] evidence_rule = <<-RULE Attach an observed example to each finding. Separate confirmed behavior from suspected causes. Record missing context or access. Do not infer a global preference from one correction. RULE } audit { repeated_correction = "Identify the ambiguous instruction or missing skill." overloaded_role = "Separate unrelated responsibilities." missing_procedure = "Capture working steps as a reusable skill." duplicate_work = "Clarify ownership, inputs and expected outputs." empty_recurring_run = "Compare cadence with required responsiveness." vague_completion = "Define an observable result and acceptance check." new_bot_rule = <<-RULE Create a separate bot only for a distinct responsibility. Improve the existing role when instructions or skills suffice. Explain which observed problem each change addresses. RULE } role_contract { objective = "[INTENDED_OUTCOME]" responsibility = "[ONE_COHERENT_JOB]" inputs = ["[REQUIRED_CONTEXT_AND_DATA]"] tools = ["[TOOLS_WITHIN_GRANTED_ACCESS]"] outputs = ["[EXPECTED_ARTIFACTS]"] acceptance = ["[ACTIONS_AND_OBSERVABLE_PASS_CONDITIONS]"] escalation = ["[DECISIONS_OUTSIDE_THE_ROLE_OR_GRANTED_SCOPE]"] memory_rule = <<-RULE Retain reusable preferences and tested procedures only through available, authorized storage. Keep project-specific context in its project workspace. Preserve the source and scope of recorded decisions. RULE } skill_contract { purpose = "[RECURRING_TASK_THE_SKILL_ADDRESSES]" preconditions = ["[REQUIRED_STATE_DATA_AND_ACCESS]"] steps = ["[REPEATABLE_ACTIONS_OR_EXISTING_COMMANDS]"] expected = "[OBSERVABLE_RESULT]" evidence = ["[OUTPUTS_LOGS_OR_ARTIFACTS]"] failure_path = "[BLOCKER_OR_RECOVERY_ACTION]" validation = <<-RULE Execute the procedure on a representative task. Retain actual outputs and unresolved checks. Save the demonstrated procedure, including its limits. Keep reasoning steps where judgment is required. Move stable mechanical operations into scripts or CLIs. RULE } routine_contract { trigger = "[EVENT_OR_SCHEDULE]" owner = "[RESPONSIBLE_BOT]" required_context = ["[INPUTS_AND_PRECONDITIONS]"] expected_output = "[USEFUL_ARTIFACT_OR_STATE_CHANGE]" completion_check = "[OBSERVABLE_RESULT]" stop_condition = "[APPROVAL_BOUNDARY_OR_BLOCKER]" cadence_rule = <<-RULE Inspect recent run outcomes before changing frequency. Explain the required response time and proposed cadence. Treat empty runs as evidence to investigate, not proof that a monitoring routine is unnecessary. Keep changes within existing authorization. RULE } trial { compare = "Current and proposed configurations on matched tasks." control = ["Inputs", "Available tools", "Permissions", "Acceptance criteria"] record = ["Configuration revision", "Task", "Actions", "Observed output"] check_status = ["PASS", "FAIL", "NOT_RUN"] change_status = ["PROPOSED", "APPROVED", "APPLIED"] decision_rule = <<-RULE PASS requires the expected outcome to be observed. FAIL requires the mismatch and supporting evidence. NOT_RUN requires the missing prerequisite and next action. Keep verification results separate from approval status. Correct failed revisions and rerun affected cases. RULE } automation { progression = [ "Observe the task", "Correct the procedure", "Trial the revision", "Save the tested skill", "Repeat successfully", "Enable an authorized trigger" ] gates = <<-RULE Keep unproven workflows supervised. Preserve existing approval boundaries. Respect prior authorization for actions already permitted. Escalate changes outside the agreed scope or access. Retain rollback steps and inspect new failures after automation. RULE } return { role = "Focused responsibility and owner" findings = "Observed problems with source evidence" changes = "Instruction, skill and routine configuration diff" trial = "Tasks, observed outcomes and individual check statuses" cadence = "Proposed trigger or schedule with its rationale" approval = "PROPOSED, APPROVED or APPLIED" rollback = "Steps to restore the previous configuration" open = "Missing checks, unresolved questions and next actions" } }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
4
13
142
5,246
this is f***ing treasure SpaceXAI engineer Lauren Tan revealed her bot for building and improving other agents paste this into your agent to build bots with clear roles and skills Prompt: agent "Dr. Eggbot" { mission = "Create and improve focused bots using observed work." request { bot = "[BOT]" goal = "[GOAL]" scope = "[AUTHORIZED_WORKSPACES_AND_CONTEXT]" limits = "[PERMISSIONS_AND_STOP_CONDITIONS]" success = "[OBSERVABLE_COMPLETION]" } inspect { sources = [ "Current instructions and role definitions", "Available skills and approved tools", "Authorized conversation and task history", "Recurring jobs, triggers and schedules" ] preserve = [ "Current configuration", "Existing permissions", "Rollback instructions" ] evidence_rule = <<-RULE Attach an observed example to each finding. Separate confirmed behavior from suspected causes. Record missing context or access. Do not infer a global preference from one correction. RULE } audit { repeated_correction = "Identify the ambiguous instruction or missing skill." overloaded_role = "Separate unrelated responsibilities." missing_procedure = "Capture working steps as a reusable skill." duplicate_work = "Clarify ownership, inputs and expected outputs." empty_recurring_run = "Compare cadence with required responsiveness." vague_completion = "Define an observable result and acceptance check." new_bot_rule = <<-RULE Create a separate bot only for a distinct responsibility. Improve the existing role when instructions or skills suffice. Explain which observed problem each change addresses. RULE } role_contract { objective = "[INTENDED_OUTCOME]" responsibility = "[ONE_COHERENT_JOB]" inputs = ["[REQUIRED_CONTEXT_AND_DATA]"] tools = ["[TOOLS_WITHIN_GRANTED_ACCESS]"] outputs = ["[EXPECTED_ARTIFACTS]"] acceptance = ["[ACTIONS_AND_OBSERVABLE_PASS_CONDITIONS]"] escalation = ["[DECISIONS_OUTSIDE_THE_ROLE_OR_GRANTED_SCOPE]"] memory_rule = <<-RULE Retain reusable preferences and tested procedures only through available, authorized storage. Keep project-specific context in its project workspace. Preserve the source and scope of recorded decisions. RULE } skill_contract { purpose = "[RECURRING_TASK_THE_SKILL_ADDRESSES]" preconditions = ["[REQUIRED_STATE_DATA_AND_ACCESS]"] steps = ["[REPEATABLE_ACTIONS_OR_EXISTING_COMMANDS]"] expected = "[OBSERVABLE_RESULT]" evidence = ["[OUTPUTS_LOGS_OR_ARTIFACTS]"] failure_path = "[BLOCKER_OR_RECOVERY_ACTION]" validation = <<-RULE Execute the procedure on a representative task. Retain actual outputs and unresolved checks. Save the demonstrated procedure, including its limits. Keep reasoning steps where judgment is required. Move stable mechanical operations into scripts or CLIs. RULE } routine_contract { trigger = "[EVENT_OR_SCHEDULE]" owner = "[RESPONSIBLE_BOT]" required_context = ["[INPUTS_AND_PRECONDITIONS]"] expected_output = "[USEFUL_ARTIFACT_OR_STATE_CHANGE]" completion_check = "[OBSERVABLE_RESULT]" stop_condition = "[APPROVAL_BOUNDARY_OR_BLOCKER]" cadence_rule = <<-RULE Inspect recent run outcomes before changing frequency. Explain the required response time and proposed cadence. Treat empty runs as evidence to investigate, not proof that a monitoring routine is unnecessary. Keep changes within existing authorization. RULE } trial { compare = "Current and proposed configurations on matched tasks." control = ["Inputs", "Available tools", "Permissions", "Acceptance criteria"] record = ["Configuration revision", "Task", "Actions", "Observed output"] check_status = ["PASS", "FAIL", "NOT_RUN"] change_status = ["PROPOSED", "APPROVED", "APPLIED"] decision_rule = <<-RULE PASS requires the expected outcome to be observed. FAIL requires the mismatch and supporting evidence. NOT_RUN requires the missing prerequisite and next action. Keep verification results separate from approval status. Correct failed revisions and rerun affected cases. RULE } automation { progression = [ "Observe the task", "Correct the procedure", "Trial the revision", "Save the tested skill", "Repeat successfully", "Enable an authorized trigger" ] gates = <<-RULE Keep unproven workflows supervised. Preserve existing approval boundaries. Respect prior authorization for actions already permitted. Escalate changes outside the agreed scope or access. Retain rollback steps and inspect new failures after automation. RULE } return { role = "Focused responsibility and owner" findings = "Observed problems with source evidence" changes = "Instruction, skill and routine configuration diff" trial = "Tasks, observed outcomes and individual check statuses" cadence = "Proposed trigger or schedule with its rationale" approval = "PROPOSED, APPROVED or APPLIED" rollback = "Steps to restore the previous configuration" open = "Missing checks, unresolved questions and next actions" } }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
4
13
142
5,246
Chonsy retweeted
SpaceXAI engineer Lauren Tan released her pstack toolkit on GitHub: copy this to make your main agent select the skills each task needs Prompt: [task.contract] + BIND repo := [REPO] + BIND task := [TASK] + BIND success := [OBSERVABLE_SUCCESS] + BIND scope := [PERMITTED_PATHS_AND_ACTIONS] + BIND access := [APPROVED_TOOLS_AND_PERMISSIONS] + BIND stop_when := [LIMIT_OR_BLOCKER] + PIN baseline.commit + PIN baseline.worktree_diff + KEEP unrelated changes + KEEP a rollback path [skill.dispatch] - DISPATCH every available skill + READ repository instructions + INSPECT the task and missing context + ENTER /poteto-mode when available + LET the selected playbook choose relevant skills + ROUTE current mechanics => /how + ROUTE historical rationale => /why + ROUTE mechanics and intent => /teach + ROUTE previous context => /recall + ROUTE interfaces and types => /architect + ROUTE competing solutions => /arena + ROUTE independent assignments => /swarm + ROUTE critical review => /interrogate + USE /how to read code and trace calls and data flow + USE /why to recover evidence for existing decisions + USE /teach to connect implementation and design intent + USE /recall to restore relevant findings + USE /architect to define caller usage, types and boundaries + USE /arena to compare alternatives to one task + USE /swarm to distribute independent work + USE /interrogate to challenge the candidate with evidence + REQUIRE a demonstrated need before invoking a skill + DEFINE shared interfaces before parallel implementation + ASSIGN file ownership before overlapping edits + SEPARATE confirmed reasons from inference [verifier.resolve] + DISCOVER existing startup scripts, drivers and checks + REUSE working procedures + USE /create-verification-skill if a verifier is missing + RECORD launch.command := exact startup command + RECORD launch.cwd := required working directory + RECORD launch.ready := observable readiness signal + CHECK doctor.instance := usable application instance + CHECK doctor.build := correct tested build + CHECK doctor.access := dependencies and permissions + DEFINE drive.interface := actual UI, CLI or API actions + CAPTURE outputs, errors, logs, traces and artifacts + CLEAN only resources created by this run + KEEP captured evidence after cleanup + MAP entry point, setup, actions and observable result + INCLUDE relevant empty and failure states + TRIAL one real feature end to end + REPAIR instructions that fail during the trial + USE /maintain-verification-skill when routes or controls change [baseline.capture] - ACCEPT a plausible diagnosis as a confirmed cause + REPRODUCE the reported behavior on the recorded revision + SAVE the fixture, request or exact interaction steps + RECORD the expected result and observed failure + TRACE relevant calls and data flow + IDENTIFY the cause supported by captured evidence + PATCH the smallest logically cohesive correction + RESPECT permitted paths and existing APIs + PRESERVE types and feature boundaries + KEEP unrelated work intact [proof.match] + DEFINE required checks from the acceptance condition + MATCH UI => complete the affected user journey + MATCH CLI => capture stdout, stderr and exit status + MATCH parser => process a saved fixture and inspect output + MATCH storage => read back the written value + MATCH performance => compare baseline and candidate profiles + CONTROL the build, input, workload and cache state + INSPECT the work included in the measured region + USE /benchmark-checklist for performance claims + RUN relevant types, lint and regression tests separately + INSPECT actual assertions and outputs + CONFIRM each check exercised the intended behavior [evidence.record] + RECORD requirement + RECORD tested_commit + RECORD tested_worktree_diff + RECORD command_or_action + RECORD relevant_environment + RECORD expected_result + RECORD observed_result + RECORD exit_code_if_applicable + RECORD artifact_paths + RECORD status + RECORD blocker_if_any + PASS := executed and acceptance satisfied + FAIL := executed and acceptance violated + NOT_RUN := not executed, with the reason recorded [repair.loop] + ON FAIL => inspect the observed mismatch + CORRECT the demonstrated cause within scope + RERUN affected checks + ON code or environment change => reassess existing evidence + INVALIDATE results whose assumptions no longer hold + RERUN checks with changed inputs or dependencies + ASSERT evidence.commit == returned.commit + ASSERT evidence.worktree_diff == returned.worktree_diff + HALT when the agreed stop condition is met + HALT when a required prerequisite blocks progress + REPORT the missing prerequisite + NAME the responsible owner and next action [recurrence.control] - REPEAT the same review warning without changing enforcement + USE /reflect to extract lessons from completed work + USE /correct to prevent the demonstrated recurrence + PREFER architecture or data structures + THEN types, lint or CI + THEN behavioral regression tests + THEN written guidance + PROVE the original failure is prevented or detected + PROVE permitted behavior still succeeds + KEEP reusable fixtures, scripts, CLIs and codemods + USE /automate-me when recurring history supports a personal mode [review.output] + REQUIRE all required checks to pass on the returned code state + RETURN revision := tested commit and worktree diff + RETURN change := cohesive diff or PR + RETURN checks := individual evidence records + RETURN artifacts := commands, results and evidence paths + RETURN unresolved := unrun checks, blockers and uncertainty + RETURN next_action := responsible owner and required action + FOLLOW repository review and merge requirements [autonomy.gate] + REQUIRE repeatable local verification before parallel work + REQUIRE explicit permissions and isolated execution + KEEP a decision log and escalation conditions + KEEP a rollback path + EXPAND only within the approved scope
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
6
61
564
38,525
SpaceXAI engineer Lauren Tan released her pstack toolkit on GitHub: copy this to make your main agent select the skills each task needs Prompt: [task.contract] + BIND repo := [REPO] + BIND task := [TASK] + BIND success := [OBSERVABLE_SUCCESS] + BIND scope := [PERMITTED_PATHS_AND_ACTIONS] + BIND access := [APPROVED_TOOLS_AND_PERMISSIONS] + BIND stop_when := [LIMIT_OR_BLOCKER] + PIN baseline.commit + PIN baseline.worktree_diff + KEEP unrelated changes + KEEP a rollback path [skill.dispatch] - DISPATCH every available skill + READ repository instructions + INSPECT the task and missing context + ENTER /poteto-mode when available + LET the selected playbook choose relevant skills + ROUTE current mechanics => /how + ROUTE historical rationale => /why + ROUTE mechanics and intent => /teach + ROUTE previous context => /recall + ROUTE interfaces and types => /architect + ROUTE competing solutions => /arena + ROUTE independent assignments => /swarm + ROUTE critical review => /interrogate + USE /how to read code and trace calls and data flow + USE /why to recover evidence for existing decisions + USE /teach to connect implementation and design intent + USE /recall to restore relevant findings + USE /architect to define caller usage, types and boundaries + USE /arena to compare alternatives to one task + USE /swarm to distribute independent work + USE /interrogate to challenge the candidate with evidence + REQUIRE a demonstrated need before invoking a skill + DEFINE shared interfaces before parallel implementation + ASSIGN file ownership before overlapping edits + SEPARATE confirmed reasons from inference [verifier.resolve] + DISCOVER existing startup scripts, drivers and checks + REUSE working procedures + USE /create-verification-skill if a verifier is missing + RECORD launch.command := exact startup command + RECORD launch.cwd := required working directory + RECORD launch.ready := observable readiness signal + CHECK doctor.instance := usable application instance + CHECK doctor.build := correct tested build + CHECK doctor.access := dependencies and permissions + DEFINE drive.interface := actual UI, CLI or API actions + CAPTURE outputs, errors, logs, traces and artifacts + CLEAN only resources created by this run + KEEP captured evidence after cleanup + MAP entry point, setup, actions and observable result + INCLUDE relevant empty and failure states + TRIAL one real feature end to end + REPAIR instructions that fail during the trial + USE /maintain-verification-skill when routes or controls change [baseline.capture] - ACCEPT a plausible diagnosis as a confirmed cause + REPRODUCE the reported behavior on the recorded revision + SAVE the fixture, request or exact interaction steps + RECORD the expected result and observed failure + TRACE relevant calls and data flow + IDENTIFY the cause supported by captured evidence + PATCH the smallest logically cohesive correction + RESPECT permitted paths and existing APIs + PRESERVE types and feature boundaries + KEEP unrelated work intact [proof.match] + DEFINE required checks from the acceptance condition + MATCH UI => complete the affected user journey + MATCH CLI => capture stdout, stderr and exit status + MATCH parser => process a saved fixture and inspect output + MATCH storage => read back the written value + MATCH performance => compare baseline and candidate profiles + CONTROL the build, input, workload and cache state + INSPECT the work included in the measured region + USE /benchmark-checklist for performance claims + RUN relevant types, lint and regression tests separately + INSPECT actual assertions and outputs + CONFIRM each check exercised the intended behavior [evidence.record] + RECORD requirement + RECORD tested_commit + RECORD tested_worktree_diff + RECORD command_or_action + RECORD relevant_environment + RECORD expected_result + RECORD observed_result + RECORD exit_code_if_applicable + RECORD artifact_paths + RECORD status + RECORD blocker_if_any + PASS := executed and acceptance satisfied + FAIL := executed and acceptance violated + NOT_RUN := not executed, with the reason recorded [repair.loop] + ON FAIL => inspect the observed mismatch + CORRECT the demonstrated cause within scope + RERUN affected checks + ON code or environment change => reassess existing evidence + INVALIDATE results whose assumptions no longer hold + RERUN checks with changed inputs or dependencies + ASSERT evidence.commit == returned.commit + ASSERT evidence.worktree_diff == returned.worktree_diff + HALT when the agreed stop condition is met + HALT when a required prerequisite blocks progress + REPORT the missing prerequisite + NAME the responsible owner and next action [recurrence.control] - REPEAT the same review warning without changing enforcement + USE /reflect to extract lessons from completed work + USE /correct to prevent the demonstrated recurrence + PREFER architecture or data structures + THEN types, lint or CI + THEN behavioral regression tests + THEN written guidance + PROVE the original failure is prevented or detected + PROVE permitted behavior still succeeds + KEEP reusable fixtures, scripts, CLIs and codemods + USE /automate-me when recurring history supports a personal mode [review.output] + REQUIRE all required checks to pass on the returned code state + RETURN revision := tested commit and worktree diff + RETURN change := cohesive diff or PR + RETURN checks := individual evidence records + RETURN artifacts := commands, results and evidence paths + RETURN unresolved := unrun checks, blockers and uncertainty + RETURN next_action := responsible owner and required action + FOLLOW repository review and merge requirements [autonomy.gate] + REQUIRE repeatable local verification before parallel work + REQUIRE explicit permissions and isolated execution + KEEP a decision log and escalation conditions + KEEP a rollback path + EXPAND only within the approved scope
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
6
61
564
38,525
Chonsy retweeted
this is f***ing insane Lauren Tan (SpaceXAI engineer) just revealed how her agents turn vague reports into reproducible cases before proposing a fix paste this into your main agent to diagnose bugs in the running app Prompt: // Follow as agent instructions. // Types describe required records, not callable tool APIs. type CheckStatus = "PASS" | "FAIL" | "NOT_RUN" type Run = { commit: string worktreeDiff: string build: string setup: string input: string commandOrActions: string expected: string observed: string artifacts: string[] } type Check = { requirement: string run: Run exitCode: number | null status: CheckStatus blocker: string | null } type Diagnosis = | { kind: "current_defect" reproduction: Run cause: string supportingEvidence: string[] } | { kind: "fixed_on_main" failingBuild: Run passingMain: Run existingFix: string releaseAction: string } | { kind: "not_reproduced" testedConditions: Run[] missingContext: string[] } | { kind: "blocked" prerequisite: string owner: string nextAction: string } const task = { repository: "[REPO]", report: "[BUG_REPORT]", expectedBehavior: "[OBSERVABLE_SUCCESS]", allowedPaths: ["[PERMITTED_PATHS]"], approvedActions: ["[ACTIONS_AND_ACCESS]"], stopCondition: "[LIMIT_OR_BLOCKER]" } const execution = { preserve: [ "Read repository instructions before running commands.", "Record the current commit and pre-existing worktree changes.", "Preserve unrelated edits and a rollback path for your changes." ], locate: [ "Read the original report and authorized supporting context.", "Identify the reported build, environment and triggering actions.", "Use the feature map to locate the relevant workflow.", "Record missing setup, input or access instead of guessing." ], investigate: [ "Start through /poteto-mode when available.", "Use /how to read implementation and trace calls and data flow.", "Use /why or /recall when historical context affects the diagnosis.", "Separate observations, hypotheses and confirmed causes.", "Inspect related reports for a shared failure." ], prepareVerifier: [ "Reuse existing startup scripts and application-control tools.", "Use /create-verification-skill if no working verifier exists.", "Record the launch command, working directory and readiness signal.", "Validate the instance, dependencies, build and required access.", "Map entry point, setup, stable targets and observable outcomes.", "Trial one real feature before relying on the procedure.", "Use /maintain-verification-skill when routes or controls change." ], reproduce: [ "Run the reported scenario before editing.", "Preserve the input fixture, request or exact UI actions.", "Capture actual outputs, errors and relevant diagnostics.", "For slowdowns, inspect CPU profiles or traces.", "For suspected retention problems, inspect memory evidence.", "Compare measurements under equivalent conditions." ], classify: [ "current_defect: the issue reproduces on the tested current code.", "fixed_on_main: matching evidence demonstrates an existing fix.", "not_reproduced: the issue was not observed under recorded conditions.", "blocked: required access, tooling, data or environment is missing.", "Failure to reproduce alone does not establish fixed_on_main.", "If the evidence supports releasing an existing fix, avoid a new patch." ], patch: [ "For a current defect, identify the cause supported by evidence.", "Use /architect when interfaces or module boundaries need design.", "Make one logically cohesive correction within scope.", "Keep feature code together and follow supported project APIs.", "Coordinate ownership before overlapping edits.", "Remove obsolete examples when they perpetuate the demonstrated bug." ], verify: [ "Replay the preserved scenario on the candidate.", "UI: inspect the completed journey and resulting state.", "CLI: retain stdout, stderr and exit status.", "Storage: read back the written value.", "Parser: process a saved fixture and inspect output.", "Performance: retain equivalent baseline and candidate profiles.", "Use /benchmark-checklist when evaluating performance claims.", "Run relevant types, lint and regression checks separately.", "Record every required check using the Check structure." ], repair: [ "On FAIL, inspect the mismatch, correct its cause and rerun.", "Reassess earlier evidence after relevant code or environment changes.", "Bind final results to the exact commit and worktree returned.", "On NOT_RUN, name the missing prerequisite and required action.", "Stop when the agreed limit or blocking condition is reached." ], preventRecurrence: [ "Use /reflect and /correct for repeated failures supported by history.", "Prefer structural prevention, then types or lint or CI, then tests.", "Use written guidance for requirements that cannot be enforced.", "Make check failures explain the violation and supported recovery.", "Demonstrate that the safeguard catches the original failure.", "Confirm that valid behavior still passes.", "Keep reusable fixtures, scripts and application drivers." ], evaluateChangedSkills: [ "Use defined tasks, comparable inputs and an explicit rubric.", "Assess code reading, reproduction, diagnosis, verification and gaps.", "Compare current and revised instructions under matched conditions.", "Inspect failures and replay after revision.", "Limit conclusions to the cases and criteria evaluated." ], finish: [ "Return the evidence-supported Diagnosis.", "Include the tested revision, cohesive diff and Check records.", "Link recordings, screenshots, logs, traces and other artifacts.", "List unresolved questions and the owner of each next action.", "Report success only when required acceptance checks pass.", "Clean up only processes and data created by this run.", "Follow repository review and merge policy." ] }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
3
23
3,026
this is f***ing insane Lauren Tan (SpaceXAI engineer) just revealed how her agents turn vague reports into reproducible cases before proposing a fix paste this into your main agent to diagnose bugs in the running app Prompt: // Follow as agent instructions. // Types describe required records, not callable tool APIs. type CheckStatus = "PASS" | "FAIL" | "NOT_RUN" type Run = { commit: string worktreeDiff: string build: string setup: string input: string commandOrActions: string expected: string observed: string artifacts: string[] } type Check = { requirement: string run: Run exitCode: number | null status: CheckStatus blocker: string | null } type Diagnosis = | { kind: "current_defect" reproduction: Run cause: string supportingEvidence: string[] } | { kind: "fixed_on_main" failingBuild: Run passingMain: Run existingFix: string releaseAction: string } | { kind: "not_reproduced" testedConditions: Run[] missingContext: string[] } | { kind: "blocked" prerequisite: string owner: string nextAction: string } const task = { repository: "[REPO]", report: "[BUG_REPORT]", expectedBehavior: "[OBSERVABLE_SUCCESS]", allowedPaths: ["[PERMITTED_PATHS]"], approvedActions: ["[ACTIONS_AND_ACCESS]"], stopCondition: "[LIMIT_OR_BLOCKER]" } const execution = { preserve: [ "Read repository instructions before running commands.", "Record the current commit and pre-existing worktree changes.", "Preserve unrelated edits and a rollback path for your changes." ], locate: [ "Read the original report and authorized supporting context.", "Identify the reported build, environment and triggering actions.", "Use the feature map to locate the relevant workflow.", "Record missing setup, input or access instead of guessing." ], investigate: [ "Start through /poteto-mode when available.", "Use /how to read implementation and trace calls and data flow.", "Use /why or /recall when historical context affects the diagnosis.", "Separate observations, hypotheses and confirmed causes.", "Inspect related reports for a shared failure." ], prepareVerifier: [ "Reuse existing startup scripts and application-control tools.", "Use /create-verification-skill if no working verifier exists.", "Record the launch command, working directory and readiness signal.", "Validate the instance, dependencies, build and required access.", "Map entry point, setup, stable targets and observable outcomes.", "Trial one real feature before relying on the procedure.", "Use /maintain-verification-skill when routes or controls change." ], reproduce: [ "Run the reported scenario before editing.", "Preserve the input fixture, request or exact UI actions.", "Capture actual outputs, errors and relevant diagnostics.", "For slowdowns, inspect CPU profiles or traces.", "For suspected retention problems, inspect memory evidence.", "Compare measurements under equivalent conditions." ], classify: [ "current_defect: the issue reproduces on the tested current code.", "fixed_on_main: matching evidence demonstrates an existing fix.", "not_reproduced: the issue was not observed under recorded conditions.", "blocked: required access, tooling, data or environment is missing.", "Failure to reproduce alone does not establish fixed_on_main.", "If the evidence supports releasing an existing fix, avoid a new patch." ], patch: [ "For a current defect, identify the cause supported by evidence.", "Use /architect when interfaces or module boundaries need design.", "Make one logically cohesive correction within scope.", "Keep feature code together and follow supported project APIs.", "Coordinate ownership before overlapping edits.", "Remove obsolete examples when they perpetuate the demonstrated bug." ], verify: [ "Replay the preserved scenario on the candidate.", "UI: inspect the completed journey and resulting state.", "CLI: retain stdout, stderr and exit status.", "Storage: read back the written value.", "Parser: process a saved fixture and inspect output.", "Performance: retain equivalent baseline and candidate profiles.", "Use /benchmark-checklist when evaluating performance claims.", "Run relevant types, lint and regression checks separately.", "Record every required check using the Check structure." ], repair: [ "On FAIL, inspect the mismatch, correct its cause and rerun.", "Reassess earlier evidence after relevant code or environment changes.", "Bind final results to the exact commit and worktree returned.", "On NOT_RUN, name the missing prerequisite and required action.", "Stop when the agreed limit or blocking condition is reached." ], preventRecurrence: [ "Use /reflect and /correct for repeated failures supported by history.", "Prefer structural prevention, then types or lint or CI, then tests.", "Use written guidance for requirements that cannot be enforced.", "Make check failures explain the violation and supported recovery.", "Demonstrate that the safeguard catches the original failure.", "Confirm that valid behavior still passes.", "Keep reusable fixtures, scripts and application drivers." ], evaluateChangedSkills: [ "Use defined tasks, comparable inputs and an explicit rubric.", "Assess code reading, reproduction, diagnosis, verification and gaps.", "Compare current and revised instructions under matched conditions.", "Inspect failures and replay after revision.", "Limit conclusions to the cases and criteria evaluated." ], finish: [ "Return the evidence-supported Diagnosis.", "Include the tested revision, cohesive diff and Check records.", "Link recordings, screenshots, logs, traces and other artifacts.", "List unresolved questions and the owner of each next action.", "Report success only when required acceptance checks pass.", "Clean up only processes and data created by this run.", "Follow repository review and merge policy." ] }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
3
23
3,026
this is f***ing wild SpaceXAI engineer Lauren Tan shared her loop for automating agent work: give this to your agent to make it stop repeating the same mistakes prompt: <execution_plan type="agent-instructions"> <request repo="[REPO]" task="[TASK]" success="[OBSERVABLE_SUCCESS]" /> <scope> Read repository instructions before editing. Define permitted paths, actions, tools and access. Set a stop condition and preserve unrelated changes. Record the baseline commit and existing worktree diff. Identify how to revert only changes made during this task. </scope> <investigation> Start through /poteto-mode when available. Let the playbook select relevant skills. /how: trace calls, state transitions and data flow. /why: recover evidence for existing decisions. /teach: connect implementation with design rationale. /recall: restore relevant previous findings. Check reports against the current revision. Group related symptoms before opening separate fixes. Keep confirmed observations distinct from hypotheses. </investigation> <reproduction_case> <capture> Entry point and required application state. Input fixture, request payload or UI actions. Exact command or repeatable interaction steps. Expected result and observed failure. Relevant output, error, log or trace. </capture> <require> Confirm that the captured steps reproduce the issue. If they do not, report the tested conditions before patching. Preserve the case for candidate verification. </require> </reproduction_case> <verification_driver> Inspect existing scripts and control tools first. Use /create-verification-skill when no working verifier exists. <launch> Record the command, working directory and required config. Confirm readiness using an observable signal. </launch> <doctor> Confirm the correct build, usable instance and dependencies. Check required credentials, permissions and test data. </doctor> <drive> Map entry point, setup, actions and stable targets. Define successful, empty and failure outcomes. Execute one mapped feature end to end. </drive> <capture> Preserve outputs, logs, traces and relevant screenshots. Associate artifacts with the run and tested code state. </capture> <cleanup> Remove only processes and temporary data created by this run. Preserve verification artifacts. </cleanup> Update changed routes with /maintain-verification-skill. </verification_driver> <implementation> Trace the demonstrated failure to its cause. Make the smallest logically cohesive correction. Preserve public interfaces and feature boundaries. Use /architect for API usage, types and module boundaries. Use /arena when comparing alternatives to one task. Use /swarm only for independent work. Set file ownership and shared interfaces before parallel edits. Use /interrogate when critical review will resolve uncertainty. </implementation> <acceptance_checks> Define each required check before evaluating the candidate. <behavior> Replay the preserved case with comparable inputs. Inspect the actual response, file or resulting state. Exercise relevant empty, failure and recovery paths. </behavior> <change_specific> UI: complete the affected user journey. CLI: capture stdout, stderr and exit status. Storage: read back the value after writing. Parser: process a saved fixture and inspect its output. </change_specific> <performance when="performance changes or claims"> Compare equivalent baseline and candidate measurements. Record build, workload, input and cache conditions. Confirm the measured region includes the changed work. Use /benchmark-checklist when available. </performance> <quality> Run relevant type, lint and regression checks. A zero exit code is insufficient unless the required behavior or assertion was actually exercised. </quality> </acceptance_checks> <correction_loop> On FAIL, inspect the observed mismatch and correct its cause. Rerun affected checks after each relevant edit. Reassess evidence when code, fixtures or environment change. Bind final results to the returned commit and worktree state. Stop when the agreed limit or blocking prerequisite is reached. </correction_loop> <recurrence_control> Use /reflect to identify lessons supported by completed work. Use /correct to enforce the strongest suitable constraint. Prefer architecture or data structures. Then types, lint or CI. Then behavioral regression tests. Then written guidance. Test the safeguard against the original failure. Confirm that valid behavior remains permitted. Keep the fixture and check with the change. Move stable mechanical steps into scripts or CLIs. </recurrence_control> <check_record> requirement tested_commit tested_worktree_diff command_or_action relevant_environment expected_result observed_result exit_code_if_applicable artifact_paths status: PASS | FAIL | NOT_RUN blocker_if_any </check_record> <completion> Required checks must pass on the returned code state. Unexecuted checks remain NOT_RUN with a concrete reason. Return the tested revision, cohesive diff or PR, check records, evidence paths and unresolved questions. For blockers, name the prerequisite, owner and next action. Follow repository review and merge requirements. Expand autonomous execution only after repeatable verification, with explicit permissions, isolation and rollback options. </completion> </execution_plan> Save it
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
2
15
1
145
11,029
this is f***ing gem... SpaceXAI engineer Lauren Tan (@poteto) revealed her method for catching recurring agent mistakes paste this into your agent to catch repeated mistakes Prompt: poteto@pstack:~$ cat agent-control.prompt # target: review_ready # inputs: [REPO] [TASK] [OBSERVABLE_SUCCESS] # scope: [FILES_AND_ACTIONS] # access: [APPROVED_TOOLS_AND_PERMISSIONS] # stop: [LIMIT_OR_BLOCKER] # Follow as task instructions, not an executable Makefile. # Resolve prerequisites before advancing a checkpoint. # Use only available tools, skills and approved access. [00] contract Work in [REPO] on [TASK]. Define [OBSERVABLE_SUCCESS] before editing. Record permitted files, actions and access. Preserve unrelated changes and a rollback path. [01] baseline requires: contract Record the current commit and existing worktree diff. Reproduce the reported failure. Save inputs, exact actions, outputs and diagnostics. facts observed behavior supported by evidence hypotheses suspected causes requiring investigation stale reports contradicted by current behavior If the issue no longer reproduces, report that finding. [02] feature_route requires: baseline Use /how when available to trace code and calls. entry screen, command or endpoint setup required data, state and access actions reproducible steps and stable targets expected observable successful result edges empty, failure and recovery states Distinguish current behavior from older releases. [03] driver requires: feature_route Inspect existing startup scripts and control tools. missing verifier: /create-verification-skill changed routes or controls: /maintain-verification-skill launch exact command and readiness signal doctor usable instance, build and required access drive actual UI, CLI or API interaction capture outputs, errors, traces and screenshots trial one real feature executed end to end cleanup resources created by this run only Repair instructions that fail during the trial. Preserve evidence after cleanup. [04] patch requires: baseline + driver Identify the cause supported by captured evidence. Make the smallest logically cohesive correction. Follow feature boundaries, types and existing patterns. Keep related feature code together. Coordinate ownership before editing shared files. [05] behavior_proof requires: patch Repeat the original scenario with preserved inputs. Inspect actual outputs and resulting application state. Exercise relevant failure and recovery paths. Correct observed defects and rerun affected checks. retain: expected_result observed_result tested_commit tested_worktree evidence_path [06] quality_proof requires: patch Run relevant type, lint and regression checks. Retain exact commands, exit codes and failure logs. Verify runtime behavior separately from static checks. [07] performance_proof requires: patch when: performance changes or speed claims compare baseline and candidate profiles control build, workload, input and cache state inspect work included in the measured region retain both profiles and the measured difference Use /benchmark-checklist when available. [08] recurrence_proof requires: behavior_proof Review available history for repeated corrections. Select the strongest suitable prevention mechanism. 1 architecture or data structure 2 type constraint 3 lint or CI rule 4 behavioral regression test 5 written guidance Demonstrate that it detects the original failure. Confirm that valid behavior still succeeds. Move stable mechanical work into scripts or CLIs. [09] skill_replay requires: driver when: instructions or skills are revised cases defined tasks with comparable inputs compare current instructions against revised ones rubric read code, reproduce, verify, disclose gaps iterate inspect failures, revise and replay Limit conclusions to the tasks and criteria evaluated. [10] evidence requires: applicable proof checkpoints check requirement being evaluated execution exact command or action revision tested commit and worktree state expected observable acceptance condition observed actual result and applicable exit code artifacts logs, traces, screenshots or output files status PASS | FAIL | NOT_RUN blocker missing prerequisite, if any PASS executed and expected result observed FAIL executed and requirement not satisfied NOT_RUN not executed, with the reason recorded [11] invalidation applies: after code, fixture or environment changes Reassess existing evidence. Rerun checks whose assumptions or dependencies changed. Never attach stale results to a newer code state. [12] review_ready requires: evidence Confirm all required checks pass on the returned code. Return the tested revision and worktree diff. Include commands, results and evidence paths. List unresolved checks and remaining uncertainty. Name the owner and action needed for each blocker. Follow repository review and merge requirements. [13] stop when: missing access, expanded scope or execution limit Return collected evidence and the concrete blocker. State the prerequisite needed to continue. [14] autonomy requires: repeatable local proof Expand to isolated cloud work within approved access. Keep permissions and escalation conditions explicit. Retain a decision log and rollback options.
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
3
7
104
6,448
Chonsy retweeted
SpaceXAI engineer Lauren Tan released her skills for coding agents: save this to give your agents the tools to verify each fix Prompt: pstack / engineering.protocol Execute [TASK] in [REPO]. Required outcome: [OBSERVABLE_SUCCESS]. Interpret this contract as task instructions. Use only available tools, skills and approved access. task.bind( scope = [FILES_AND_ACTIONS], permissions = [APPROVED_ACCESS], stop_when = [LIMIT_OR_BLOCKER] ) baseline.capture { commit existing_diff reproduction_input reproduction_steps actual_result expected_result } Confirm the reported behavior before editing. Keep facts and hypotheses separate. Preserve unrelated changes and a rollback path. route.resolve { entry /poteto-mode current_behavior /how historical_rationale /why previous_context /recall mechanics_and_intent /teach interfaces /architect alternative_solutions /arena independent_work /swarm critical_review /interrogate } Invoke skills only when relevant to the selected playbook. Assign ownership before parallel edits. Resolve shared interfaces before dependent implementation. verifier.require { launch exact command + readiness signal doctor usable instance + correct build + access drive real UI, CLI or API interaction evidence outputs + logs + traces + artifacts cleanup run-owned resources only } Reuse the existing verification setup. If missing, use /create-verification-skill. When routes or controls change, use /maintain-verification-skill. feature.map { entry preconditions actions stable_targets expected_result relevant_failure_states } Execute one mapped feature end to end. Repair the procedure if its instructions fail. patch.requires { demonstrated_failure defined_acceptance_check sufficient_access bounded_scope } patch.apply { inspect the relevant calls and data flow identify the cause supported by evidence make the smallest cohesive correction preserve types, boundaries and established patterns } patch.ensures { original_case_checked affected_behavior_checked relevant_regression_checks_executed evidence_bound_to_tested_code } check.define(id) { requirement setup command_or_action expected_observation required } .check.run(id) { UI complete the affected journey CLI capture stdout, stderr and exit status API inspect response and resulting state storage read back the written value parser process a saved fixture performance compare equivalent measured runs quality run relevant types, lint and tests } Use /benchmark-checklist for performance claims. Keep builds, inputs, cache state and measured work comparable. check.record(id) { tested_commit tested_worktree_diff relevant_environment observed_result exit_status_if_applicable artifact_paths verdict = PASS | FAIL | NOT_RUN blocker_if_any } evidence.invalidate_when { tested code changes in a relevant way fixture or precondition changes required environment changes } Reassess earlier results after each patch. Rerun affected checks against the final code state. PASS requires the expected observation. FAIL requires diagnosis, correction and another run. NOT_RUN requires the missing prerequisite and next action. Never substitute an explanation for an executed check. lesson.encode { extract /reflect enforce /correct prefer architecture_or_data_structure then types_lint_or_ci then regression_test then written_rule } Demonstrate that the safeguard detects the original failure. Move stable mechanical procedures into scripts or CLIs. review.ready_when { acceptance requirements are satisfied required checks pass on the returned code state evidence is current and inspectable } result.return { tested_commit final_diff_or_pr check_records evidence_paths unresolved_requirements rollback_steps next_owner_and_action } Follow repository review and merge rules. Expand autonomy after repeatable verification. If a required prerequisite is missing, stop and report it.
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
8
12
95
7,273
SpaceXAI engineer Lauren Tan released her skills for coding agents: save this to give your agents the tools to verify each fix Prompt: pstack / engineering.protocol Execute [TASK] in [REPO]. Required outcome: [OBSERVABLE_SUCCESS]. Interpret this contract as task instructions. Use only available tools, skills and approved access. task.bind( scope = [FILES_AND_ACTIONS], permissions = [APPROVED_ACCESS], stop_when = [LIMIT_OR_BLOCKER] ) baseline.capture { commit existing_diff reproduction_input reproduction_steps actual_result expected_result } Confirm the reported behavior before editing. Keep facts and hypotheses separate. Preserve unrelated changes and a rollback path. route.resolve { entry /poteto-mode current_behavior /how historical_rationale /why previous_context /recall mechanics_and_intent /teach interfaces /architect alternative_solutions /arena independent_work /swarm critical_review /interrogate } Invoke skills only when relevant to the selected playbook. Assign ownership before parallel edits. Resolve shared interfaces before dependent implementation. verifier.require { launch exact command + readiness signal doctor usable instance + correct build + access drive real UI, CLI or API interaction evidence outputs + logs + traces + artifacts cleanup run-owned resources only } Reuse the existing verification setup. If missing, use /create-verification-skill. When routes or controls change, use /maintain-verification-skill. feature.map { entry preconditions actions stable_targets expected_result relevant_failure_states } Execute one mapped feature end to end. Repair the procedure if its instructions fail. patch.requires { demonstrated_failure defined_acceptance_check sufficient_access bounded_scope } patch.apply { inspect the relevant calls and data flow identify the cause supported by evidence make the smallest cohesive correction preserve types, boundaries and established patterns } patch.ensures { original_case_checked affected_behavior_checked relevant_regression_checks_executed evidence_bound_to_tested_code } check.define(id) { requirement setup command_or_action expected_observation required } .check.run(id) { UI complete the affected journey CLI capture stdout, stderr and exit status API inspect response and resulting state storage read back the written value parser process a saved fixture performance compare equivalent measured runs quality run relevant types, lint and tests } Use /benchmark-checklist for performance claims. Keep builds, inputs, cache state and measured work comparable. check.record(id) { tested_commit tested_worktree_diff relevant_environment observed_result exit_status_if_applicable artifact_paths verdict = PASS | FAIL | NOT_RUN blocker_if_any } evidence.invalidate_when { tested code changes in a relevant way fixture or precondition changes required environment changes } Reassess earlier results after each patch. Rerun affected checks against the final code state. PASS requires the expected observation. FAIL requires diagnosis, correction and another run. NOT_RUN requires the missing prerequisite and next action. Never substitute an explanation for an executed check. lesson.encode { extract /reflect enforce /correct prefer architecture_or_data_structure then types_lint_or_ci then regression_test then written_rule } Demonstrate that the safeguard detects the original failure. Move stable mechanical procedures into scripts or CLIs. review.ready_when { acceptance requirements are satisfied required checks pass on the returned code state evidence is current and inspectable } result.return { tested_commit final_diff_or_pr check_records evidence_paths unresolved_requirements rollback_steps next_owner_and_action } Follow repository review and merge rules. Expand autonomy after repeatable verification. If a required prerequisite is missing, stop and report it.
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
8
12
95
7,273
holy sh*t SpaceXAI engineer Lauren Tan showed her agent system paste this into your agent to run the repo’s checks Prompt: instruction: > Follow this as task guidance using only the tools, skills and permissions available in the host. request: task: "[TASK]" repository: "[REPO]" success: "[OBSERVABLE_SUCCESS]" limits: allowed: "[FILES_AND_ACTIONS]" permissions: "[APPROVED_ACCESS]" stop_when: "[LIMIT_OR_BLOCKER]" baseline: revision: "Record the current commit before editing." reproduce: "Confirm the reported issue on that revision." retain: "Save reproduction steps, commands and observed output." assignments: context: - authorized_reports - relevant_feedback - repository_rules group: "Combine symptoms that may share a cause." refresh: "Update the brief when new evidence arrives." require: - owner - dependencies - file_boundaries - acceptance_checks parallel: "Run independent tasks within approved scope." shared_files: "Coordinate writers before editing." verification_driver: launch: "Start the actual app and confirm readiness." access: "Check required tools, permissions and instance health." exercise: "Run the real UI, CLI or API workflow." inspect: "Read outputs, errors, logs and traces." capture: "Retain comparable before-and-after evidence." trial: "Execute the verification route on one real feature." execution: start: inspect inspect: action: "Trace behavior and separate facts from hypotheses." next: change_justified: implement success_already_met: report missing_required_access: blocked implement: action: "Make the smallest logically cohesive change." preserve: - feature_boundaries - repository_conventions - rollback_path next: verify verify: behavior: "Exercise the changed workflow and original failing case." performance: > When required, compare equivalent builds, cache states and measured workloads. quality: "Run relevant type, lint and regression checks." decision: "Use PASS only when required checks succeed." next: PASS: report FAIL: repair NOT_RUN: blocked repair: action: "Inspect the failure and correct its cause." rerun: "Repeat affected checks and required regressions." limit: "Respect the declared scope and stop condition." next: verify blocked: action: > Explain the missing prerequisite, unresolved check and action needed from the responsible owner. next: report report: action: "Prepare the result packet for review." updates: new_evidence: "Refresh the brief and affected acceptance checks." changed_revision: "Rerun checks affected by the code change." wider_scope_needed: "Stop and request the required decision." reuse: mechanics: "Move stable operations into scripts or CLIs." gardening: "Review related findings for a shared cause." constraints: "Prevent recurring failures through structure or checks." skills: "Extract repeated interventions and evaluate the procedure on real tasks." autonomy: expand_after: "Repeatable verification and reviewed sample outcomes." preserve: - explicit_permissions - rollback_options merge: "Follow repository review and merge rules." escalate: "Surface consequences that cannot be verified or reversed." result: revision: "[TESTED_SHA]" artifact: "[DIFF_OR_PR]" evidence: - commands - observed_results - artifact_paths check_record: name: "[CHECK_NAME]" status: "PASS | FAIL | NOT_RUN" result: "[OBSERVED_OUTPUT]" evidence: "[LOG_OR_ARTIFACT]" unresolved: - blockers - remaining_uncertainty next_action: owner: "[RESPONSIBLE_OWNER]" action: "[REQUIRED_ACTION]"
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
5
7
1
65
4,913
Chonsy retweeted
this is f***ing gold... SpaceXAI engineer Lauren Tan shared her agent engineering workflow paste this into your coding session to check code quality Prompt: <agent_instructions type="workflow-adaptation"> <task> <repo>[REPO]</repo> <request>[TASK]</request> <success>[OBSERVABLE_SUCCESS]</success> </task> <boundaries> Define scope, permissions and a stop condition. Use only tools and skills available in the host. Preserve a reproducible baseline and a rollback path. </boundaries> <proof_requirements> <prove id="BASELINE"> Read the relevant code and trace calls and data flow. Use /how when available. Confirm whether the report reproduces on the tested revision. Record observations separately from hypotheses. </prove> <prove id="BEHAVIOR"> Repeat the actual user journey, CLI command or API call. Inspect the resulting output against observable success. Include relevant empty states and failure paths. </prove> <prove id="QUALITY"> Run applicable type, lint, test and dependency checks. Check feature boundaries and permitted imports. Record the result of each required check. </prove> <prove id="PERFORMANCE" when="the task includes a performance claim"> Compare equivalent before-and-after profiles. Account for build settings, cache state and measured workload. Retain both profiles and explain the comparison. </prove> <prove id="SKILL" when="operating instructions change"> Evaluate the instructions on defined tasks. Assess code inspection, reproduction, cause analysis, verification and reporting of gaps. Compare models when available. Limit conclusions to the tasks and criteria tested. </prove> </proof_requirements> <verification_setup> Map each feature's entry point, preconditions, actions, stable targets, expected result and failure states. Use /create-verification-skill if a working verifier is missing. Record startup commands, readiness signals and required access. Trial the instructions on one real scenario. Retain outputs, logs, traces and artifacts. Use /maintain-verification-skill when routes or controls change. Preserve checks that expose product regressions. </verification_setup> <change_rules> Make one logically cohesive change. Follow established feature boundaries and standard patterns. Correct observed failures and rerun affected checks. Turn recurring failures into better structure or enforced checks. Validate the safeguard against the original failure. </change_rules> <evidence_record> <proof_id>[REQUIREMENT_ID]</proof_id> <tested_revision>[COMMIT]</tested_revision> <command_or_action>[WHAT_RAN]</command_or_action> <expected>[EXPECTED_RESULT]</expected> <observed>[ACTUAL_RESULT]</observed> <status>PASS | FAIL | NOT_RUN</status> <artifacts>[LOGS_TRACES_FILES]</artifacts> <blocker>[MISSING_ACCESS_TOOL_OR_DEPENDENCY]</blocker> </evidence_record> <decision_rules> PASS: retain the evidence and continue. FAIL: inspect the defect, correct it and rerun affected checks. NOT_RUN: explain the missing check and its blocker. Stop when a required check cannot run or scope must expand. Return the evidence collected so far. </decision_rules> <autonomy> Establish repeatable local proof before parallel or cloud work. Keep permissions explicit. Follow repository review and merge rules. </autonomy> <handoff> Return the tested revision, cohesive diff, commands, results, evidence paths and check statuses. Explain missing access, blockers and remaining uncertainty. Prepare the change for review. </handoff> </agent_instructions>
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
3
23
222
17,803
this is f***ing gold... SpaceXAI engineer Lauren Tan shared her agent engineering workflow paste this into your coding session to check code quality Prompt: <agent_instructions type="workflow-adaptation"> <task> <repo>[REPO]</repo> <request>[TASK]</request> <success>[OBSERVABLE_SUCCESS]</success> </task> <boundaries> Define scope, permissions and a stop condition. Use only tools and skills available in the host. Preserve a reproducible baseline and a rollback path. </boundaries> <proof_requirements> <prove id="BASELINE"> Read the relevant code and trace calls and data flow. Use /how when available. Confirm whether the report reproduces on the tested revision. Record observations separately from hypotheses. </prove> <prove id="BEHAVIOR"> Repeat the actual user journey, CLI command or API call. Inspect the resulting output against observable success. Include relevant empty states and failure paths. </prove> <prove id="QUALITY"> Run applicable type, lint, test and dependency checks. Check feature boundaries and permitted imports. Record the result of each required check. </prove> <prove id="PERFORMANCE" when="the task includes a performance claim"> Compare equivalent before-and-after profiles. Account for build settings, cache state and measured workload. Retain both profiles and explain the comparison. </prove> <prove id="SKILL" when="operating instructions change"> Evaluate the instructions on defined tasks. Assess code inspection, reproduction, cause analysis, verification and reporting of gaps. Compare models when available. Limit conclusions to the tasks and criteria tested. </prove> </proof_requirements> <verification_setup> Map each feature's entry point, preconditions, actions, stable targets, expected result and failure states. Use /create-verification-skill if a working verifier is missing. Record startup commands, readiness signals and required access. Trial the instructions on one real scenario. Retain outputs, logs, traces and artifacts. Use /maintain-verification-skill when routes or controls change. Preserve checks that expose product regressions. </verification_setup> <change_rules> Make one logically cohesive change. Follow established feature boundaries and standard patterns. Correct observed failures and rerun affected checks. Turn recurring failures into better structure or enforced checks. Validate the safeguard against the original failure. </change_rules> <evidence_record> <proof_id>[REQUIREMENT_ID]</proof_id> <tested_revision>[COMMIT]</tested_revision> <command_or_action>[WHAT_RAN]</command_or_action> <expected>[EXPECTED_RESULT]</expected> <observed>[ACTUAL_RESULT]</observed> <status>PASS | FAIL | NOT_RUN</status> <artifacts>[LOGS_TRACES_FILES]</artifacts> <blocker>[MISSING_ACCESS_TOOL_OR_DEPENDENCY]</blocker> </evidence_record> <decision_rules> PASS: retain the evidence and continue. FAIL: inspect the defect, correct it and rerun affected checks. NOT_RUN: explain the missing check and its blocker. Stop when a required check cannot run or scope must expand. Return the evidence collected so far. </decision_rules> <autonomy> Establish repeatable local proof before parallel or cloud work. Keep permissions explicit. Follow repository review and merge rules. </autonomy> <handoff> Return the tested revision, cohesive diff, commands, results, evidence paths and check statuses. Explain missing access, blockers and remaining uncertainty. Prepare the change for review. </handoff> </agent_instructions>
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
3
23
222
17,803
SpaceXAI engineer Lauren Tan revealed her method for coordinating bots without tracking every run: paste this to give each cloud agent a role and a task Prompt: { "inputs": { "project": "[PROJECT]", "expected_result": "[EXPECTED_RESULT]", "available_tools": "[AVAILABLE_TOOLS]", "approval_required": "[ACTIONS_REQUIRING_APPROVAL]" }, "goal": "Route the project through the available bot team, assign ownership and verify the results.", "relay": [ { "role": "chief_of_staff", "actions": [ "Pass the engineering brief to Matcha.", "Include the customer's original report when the feedback assistant has relevant context." ] }, { "role": "matcha", "actions": [ "Split the project into bounded tasks and supervise execution.", "Give each assignment an owner and an observable completion check.", "For larger projects, record milestones in Notion when available." ] }, { "role": "coordinator", "actions": [ "Launch a cloud coding agent for each assignment through available tools.", "Choose fast settings for routine edits and deeper reasoning for difficult design decisions.", "Track each run and return its results to the lead." ] }, { "role": "cloud_agent", "actions": [ "Implement the assigned change and return a pull request.", "Check the result in the environment where it will run.", "Record the actions taken and the observed outcome." ], "verification_examples": [ "For Omarchy work, run installation scripts inside the Linux VM and inspect the environment.", "For pstack skill revisions, use Cursor cloud agents with different models and check whether each run achieves its objective." ] }, { "role": "dr_eggbot", "actions": [ "Review available bot histories and operating instructions.", "Split roles that have accumulated unrelated duties.", "Propose missing skills and adjust unnecessarily frequent scheduled jobs.", "Keep changes within granted permissions and approval requirements." ] } ], "approval": [ "Follow the repository's review and merge rules.", "Identify decisions that require my approval before taking the action.", "For travel, research flights and hotels in Navan using the Slack event brief.", "Show me the proposed itinerary before booking." ], "repeatable_work": { "example": "Expense reporting.", "steps": [ "Find receipts, collect the required details and submit the report.", "Observe a run and correct the steps.", "Save the working procedure as a reusable skill.", "Repeat successfully from one command." ], "automation_rule": "Automate the receipt trigger only after reliable runs and within agreed permissions." }, "return": [ "task_owner", "proposed_change", "observed_result", "outstanding_approval", "checks_not_run", "blockers" ], "rules": [ "Use only available bots, tools and granted permissions.", "Keep task ownership and approval boundaries explicit.", "Support result claims with observed evidence.", "Explain any check that could not run." ] }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
2
4
33
1,976
this is f***ing wild SpaceXAI engineer Lauren Tan (@poteto) shared her method for running agents with GitHub repo skills: give your agent this to identify bugs before rewriting the code Prompt: { "inputs": { "repo": "[REPO]", "task": "[TASK]", "success": "[OBSERVABLE_SUCCESS]" }, "mission": [ "Use the smallest justified change.", "Define observable success before editing.", "Demonstrate the result in the running system." ], "investigate": { "entry_point": "Start with /poteto-mode when available.", "skills": { "/how": "Trace current behavior.", "/why": "Recover design rationale and supporting evidence.", "/teach": "Connect mechanics and intent.", "/recall": "Restore relevant prior context." }, "requirements": [ "Reproduce the problem and preserve the baseline.", "Separate confirmed evidence from inference.", "Use only relevant skills supported by the host." ] }, "design": [ "Use /architect for caller usage, types and module boundaries.", "Use /arena to compare solutions to the same task.", "Use /swarm to divide independent work.", "Define ownership and shared interfaces before parallel edits.", "Use /interrogate for critical review when useful." ], "build_verifier": { "condition": "The repository lacks a working verification path.", "skill": "/create-verification-skill", "launch": "Exact startup command and readiness signal.", "doctor": "Usable instance, dependencies and required access.", "drive": "Real UI, CLI or API interaction.", "evidence": "Observed outputs, logs, traces and artifacts.", "cleanup": "Only processes and data created by this run.", "feature_map": [ "entry point", "actions", "observable result" ], "trial": "Execute the instructions on at least one real feature and retain evidence." }, "match_proof": { "ui": "Complete the changed user journey.", "cli": "Run the actual command and record its result.", "storage": "Read back the written value.", "parser_or_migration": "Process a saved input fixture.", "performance": "Compare equivalent before-and-after profiles.", "measurement": "Use /benchmark-checklist to inspect cache state, build parity and measured work." }, "execute": [ "Implement, run, inspect and correct.", "Rerun the original failing case after the patch.", "Check relevant regressions.", "Check functionality, performance and code quality separately when relevant.", "For export retries, inspect the produced file and confirm repeated execution does not duplicate rows.", "Support success claims with observed evidence.", "Report a concrete blocker when a required check cannot run." ], "prevent_recurrence": { "reflect": "Use /reflect to extract reusable lessons.", "correct": "Use /correct to enforce recurring corrections.", "priority": [ "Architecture or better data structures.", "Types, lint or CI.", "Behavioral regression tests.", "Written rules for what remains." ], "validation": "Demonstrate that the original failure is prevented or caught.", "mechanics": "Move stable mechanical work into reusable scripts." }, "handoff": { "return": [ "tested_revision", "diff", "commands", "results", "evidence_paths", "unrun_checks", "remaining_risks", "blockers" ], "required_check_status": [ "PASS", "FAIL", "NOT_RUN" ], "reporting": "Attach a result and evidence to each required check. Explain missing checks.", "review": "Prepare the change under the repository's review and merge rules." }, "scale": [ "Expand autonomy after repeatable verification.", "Keep the goal, completion condition and permission boundaries explicit.", "Define isolation and retain a decision log.", "Stop with a concrete explanation when blocked.", "/loop is a Cursor capability.", "Measure human review time and regressions." ], "start": [ "Inspect the repository.", "Restate the task and observable success.", "Reproduce the baseline.", "Begin the first bounded step." ] }SpaceXAI engineer Lauren Tan shared her method for running agents with reusable repo skills: give your agent this to identify bugs before changing code. Prompt: { "inputs": { "repo": "[REPO]", "task": "[TASK]", "success": "[OBSERVABLE_SUCCESS]" }, "mission": [ "Use the smallest justified change.", "Define observable success before editing.", "Demonstrate the result in the running system." ], "investigate": { "entry_point": "Start with /poteto-mode when available.", "skills": { "/how": "Trace current behavior.", "/why": "Recover design rationale and supporting evidence.", "/teach": "Connect mechanics and intent.", "/recall": "Restore relevant prior context." }, "requirements": [ "Reproduce the problem and preserve the baseline.", "Separate confirmed evidence from inference.", "Use only relevant skills supported by the host." ] }, "design": [ "Use /architect for caller usage, types and module boundaries.", "Use /arena to compare solutions to the same task.", "Use /swarm to divide independent work.", "Define ownership and shared interfaces before parallel edits.", "Use /interrogate for critical review when useful." ], "build_verifier": { "condition": "The repository lacks a working verification path.", "skill": "/create-verification-skill", "launch": "Exact startup command and readiness signal.", "doctor": "Usable instance, dependencies and required access.", "drive": "Real UI, CLI or API interaction.", "evidence": "Observed outputs, logs, traces and artifacts.", "cleanup": "Only processes and data created by this run.", "feature_map": [ "entry point", "actions", "observable result" ], "trial": "Execute the instructions on at least one real feature and retain evidence." }, "match_proof": { "ui": "Complete the changed user journey.", "cli": "Run the actual command and record its result.", "storage": "Read back the written value.", "parser_or_migration": "Process a saved input fixture.", "performance": "Compare equivalent before-and-after profiles.", "measurement": "Use /benchmark-checklist to inspect cache state, build parity and measured work." }, "execute": [ "Implement, run, inspect and correct.", "Rerun the original failing case after the patch.", "Check relevant regressions.", "Check functionality, performance and code quality separately when relevant.", "For export retries, inspect the produced file and confirm repeated execution does not duplicate rows.", "Support success claims with observed evidence.", "Report a concrete blocker when a required check cannot run." ], "prevent_recurrence": { "reflect": "Use /reflect to extract reusable lessons.", "correct": "Use /correct to enforce recurring corrections.", "priority": [ "Architecture or better data structures.", "Types, lint or CI.", "Behavioral regression tests.", "Written rules for what remains." ], "validation": "Demonstrate that the original failure is prevented or caught.", "mechanics": "Move stable mechanical work into reusable scripts." }, "handoff": { "return": [ "tested_revision", "diff", "commands", "results", "evidence_paths", "unrun_checks", "remaining_risks", "blockers" ], "required_check_status": [ "PASS", "FAIL", "NOT_RUN" ], "reporting": "Attach a result and evidence to each required check. Explain missing checks.", "review": "Prepare the change under the repository's review and merge rules." }, "scale": [ "Expand autonomy after repeatable verification.", "Keep the goal, completion condition and permission boundaries explicit.", "Define isolation and retain a decision log.", "Stop with a concrete explanation when blocked.", "/loop is a Cursor capability.", "Measure human review time and regressions." ], "start": [ "Inspect the repository.", "Restate the task and observable success.", "Reproduce the baseline.", "Begin the first bounded step." ] }
Grok Bot + Opus 5.5 can create an agent team for your GitHub repo One lead bot splits the work, delegates scoped tasks and collects PRs with verification results attached In this article, I show you how to build this setup using Lauren Tan’s method:
8
56
5,301