Chase

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:

wow, this is f***ing insane SpaceXAI engineer Lauren Tan shared her agent system for delegating code through a team of bots: → Chief of staff (project brief) routes the engineering request to Matcha with the project goal and relevant context → Matcha (assignments) breaks the project into bounded tasks. larger milestones and progress stay in Notion Each assignment defines: task / owner / dependencies / acceptance_checks → Coordinators (cloud runs) launch a cloud agent per assignment and select its model and reasoning depth assigned_task / model / reasoning_depth / run_reference → Cloud agents (pull requests) implement the change, run scripts and inspect the application or VM The return includes: PR / observed_outputs / check_results / approval_needed test changes to the team itself > Omarchy: run installation scripts inside the Linux VM and inspect the environment > pstack: have Cursor cloud agents execute revised skills across models and check the intended outcome > Dr. Eggbot: audit histories, split overloaded roles and adjust recurring jobs define approval per workflow some code changes merge before Lauren reviews them in her established environment Session requires approval before purchase: Slack brief → Navan research → itinerary review → booking a brief the team can reuse → team-brief.prompt > route [PROJECT] to an owner. split independent tasks and define a check for each result > return proposed changes, observed outputs and decisions that need my approval For recurring work, save the corrected steps as a skill > add a trigger only after the task works reliably from one command Save this to stop babysitting every coding session ↓

this is f***ing gold SpaceXAI engineer Lauren Tan showed how to make agents test real features: start with /create-verification-skill to build the repo’s verification process → Define the result as an assertion For example, a saved setting must survive a reload: value_after_reload == expected_value value_read_from_storage == expected_value the repo skill records how to start the app, reach that setting, change it and collect both results its trial produces a screenshot, the storage read-back and the commands used Temporary test data gets cleaned up afterward if storage access is unavailable, that check stays NOT_RUN with a recorded blocker → Measure performance separately if the task includes a speedup, capture baseline and candidate profiles with equivalent build settings, input data and cache conditions 1. use /benchmark-checklist to confirm the measured region includes the work being changed 2. keep both profiles with the result the feature assertion proves the behavior, while the profiles support the performance claim. → Leave a safeguard in the repo /reflect - identifies the recurring failure /correct - helps prevent it through architecture or types, then lint, CI or a behavioral test For a regression test, require both: > original revision → FAIL > patched revision → PASS use the same input fixture for both runs. keep the test with the fix so later changes are checked against the original failure Save this to turn one working check into a reusable skill

F**k all $500 AI agent courses... Grok Bot engineer Lauren Tan (@poteto) revealed her agent system for coordinating code and everyday work: 1. Request routing project goal → Matcha → coordinators → cloud coding agents → PRs > Matcha splits the project into bounded assignments with owner / dependencies / acceptance_checks coordinators launch the coding runs cloud agents implement changes, run scripts and inspect the application or VM The feedback assistant feeds customer reports into engineering, giving executors the context behind the proposed fix Personal work follows a separate route: Slack event details → travel assistant → Navan proposal → Lauren’s approval → booking the assistant researches flights and hotels Lauren reviews the arrangements before purchase 2. Team maintenance > Dr. Eggbot audits bot instructions, recent conversations and recurring jobs → overloaded responsibilities become narrower roles → repeated explanations become skill proposals → wasteful runs lead to cadence changes > pstack evaluations test whether revised instructions actually help: changed skill → Cursor cloud agents → different models → observed task result the evaluation checks whether the objective was achieved and retains evidence from execution proposed improvements get a real trial before automation Two prompts to adapt the setup: → delegate.prompt > break [goal] into bounded assignments > define an owner, required context, available tools and observable checks for each task > return assignments, evidence and unresolved questions → improve.prompt > review [bot] instructions, recent work and recurring runs > propose a focused role, reusable skills and a sensible run frequency > test the changes on a real task before automation Save this to stop routing every task yourself ↓

this is f***ing gem SpaceXAI engineer Lauren Tan explained her method for teaching agents to test real features “...to delegate 80% of a workflow, I turn my manual checks into a reusable verification skill.” in this guide, she breaks down how "pstack" routes each request to a playbook and selects the skills it needs: → Build a runnable verifier (create-verification-skill) The generated procedure must: 1. launch the app and confirm the instance is ready 2. reach a feature, perform the actions and inspect the result 3. retain evidence and clean up its processes and temporary data trial the instructions on one real feature before reusing them → Require proof that fits the change: > UI - the completed journey and observed result > CLI - the command, output and exit status > storage - the value read back after writing > performance - profiles with comparable builds, cache states and workloads /benchmark-checklist - helps catch misleading measurements when the same correction returns, use /correct to strengthen the repo. prefer an architectural constraint, then types, lint or CI, then a behavioral test The safeguard must catch the original failure predictable mechanical steps belong in scripts the next agent can reuse Watch this before launching more coding agents

I can't f***ing believe this... SpaceXAI engineer Lauren Tan revealed her setup for keeping agents working with fresh context use these 3 prompts: > coordinate.prompt groups related reports and checks which failures still reproduce on current main when several reports share a cause, they become one bounded task. new findings update its source links, scope and acceptance checks The assignment stays compact: goal / owner / scope / depends_on / acceptance_checks / source_links independent tasks can run in parallel. shared-file changes need coordinated ownership verification follows the candidate SHA > verify.prompt checks the exact revision against the original requirements The review preserves five things: → revision - the commit that was tested → repro - steps and baseline behavior → run - commands and exit codes → proof - logs, traces and artifacts → limits - checks that couldn’t run and their blockers an observed defect sends the patch back for repair. a missing dependency leaves the affected check unverified a new commit requires fresh verification evidence. recurring failures enter the gardening queue > garden.prompt groups failures from task history and looks for their shared cause it proposes a structural constraint first, then types, lint or CI, then a behavioral test. repeatable mechanical steps move into scripts or CLIs the proposed safeguard must demonstrate that it prevents or catches the original failure Save this to spend less time updating agents ↓

that's f***ing wild SpaceXAI’s (@bot) team showed how they delegate coding, content and design to agents Start with the artifact you need: → Tested PR (Lauren Tan’s engineering agents) > engineering.prompt takes the repo, goal and acceptance checks > Matcha maps dependencies and assigns owners > coordinators launch cloud coding runs > verifier agents reproduce the issue and check the changed behavior The handoff contains: tested_commit / diff / commands / results / evidence / unresolved_checks > Dr. Eggbot audits the setup for overloaded roles, repeated corrections and redundant runs → A working demo (Matt Palmer’s Tech Demos bot) > demo.prompt turns a bookmarked technology into a scoped build proposal brief → approval → Cursor Cloud Agent → apps/<slug>/ > the PR includes a screenshot, a running-app video and the commands used unrelated apps stay outside the change For content, the work splits again: > Marketing Review returns before / after / rule / rationale > Social Media Review takes Slack requests through revision, approval and Typefully scheduling → Connected design flow (Peng Zheng’s design bot) > design.prompt starts from a reference screen and the required flow > Figma MCP + a reusable design skill extend existing components, tokens, typography and spacing across the remaining states > the PM, designer and engineer bots review requirements and feasibility in a shared project chat. the design handoff includes frame links, changes and open decisions a separate Website bot turns photos, locations and repo scripts into processed assets and a site update Record each check with its evidence: checks: [{ name, status, evidence }] > use PASS / FAIL / NOT_RUN > track approval separately (a passing check doesn’t authorize a merge or a scheduled post) Save this before spending $1,000 on agent courses ↓

this is f***ing gold SpaceXAI engineer Lauren Tan shows how pstack works: start with /poteto-mode to route the task through the right playbook > Define the task goal / constraints / observable_success /poteto-mode selects the playbook. skills such as /how, /why and /architect supply context and design work when needed > Verify the running app /create-verification-skill Builds and trials a repo-specific procedure: launch → doctor → drive → evidence → cleanup The proof depends on the change: → UI: complete the affected user journey → CLI: capture the command, output and exit status → storage: read back the written value → performance: compare profiles under equivalent conditions > Hand off the tested change tested_commit / diff / commands + results / evidence_paths Failed checks send the change back for repair Unavailable checks stay listed under unverified_checks, with the missing dependency explained > Prevent recurring failures /reflect - captures the lesson /correct - helps encode it through architecture, types, lint, CI or tests predictable mechanical work moves into scripts so the next run can reuse it Save this to spend less time supervising fixes ↓

this is f***ing insane Grok Bot engineer Lauren Tan revealed her coding agent team use these prompts to build your own coding team: → Researcher (research.prompt) Find why [bug] happens in [repo] Keep the code unchanged. Show the failing command, relevant source locations and what remains uncertain → Architect (design.prompt) Use the findings to plan the smallest fix. For each assignment, specify: owned_files / dependencies / acceptance_check Settle shared interfaces before parallel work begins → Builder (build.prompt) Implement the assigned fix within scope. Rebuild, rerun the failing case and check related behavior Attach the tested commit, diff and actual command results → Verifier (verify.prompt) > Check [candidate_SHA] independently against the original requirements > Exercise the affected UI, CLI or API > Report PASS, FAIL or BLOCKED, with evidence for the verdict. If the commit changes, repeat the check. → Gardener (improve.prompt) Take a mistake that keeps returning and make the repo catch it Prefer an architectural constraint, then types, lint or CI, then a behavioral test Show that the safeguard detects the original failure Save these prompts to build your own coding team ↓

this is f***ing gold Grok Bot engineer Lauren Tan showed her prompt for building Matcha agent: paste matcha-dispatch.prompt to create your own coding team lead then give it your project brief and repo context Matcha turns them into: → Plan the team can execute Assignments with: task_id / owner / depends_on / scope / completion_check → Parallel work with clear boundaries > independent tasks [separate branches and environments] > shared files or interfaces [sequenced changes] > related reports are consolidated so multiple agents don’t build duplicate fixes → Progress backed by evidence Each handoff carries: run_url / commit / diff / checks / artifacts / blockers Matcha reviews the combined candidate against the original brief and returns PRs, verification evidence and unresolved decisions Save this to give your coding agents a team lead ↓

I was f***ing shocked... SpaceXAI’s team released prompts to build and manage a whole agent team: Here’s how to split the work into two paths: 1. Lauren Tan (@poteto) - configure + delegate → Dr. Eggbot (build the bot team) > audit instructions and recent conversations for overlapping roles, overloaded context and repeated corrections > propose focused configuration changes with a test task and pass condition flag permission changes for approval → Matcha (coordinate engineering) > turn the brief into tasks with owners, dependencies and file boundaries > coding agents implement the changes and return PRs with verification evidence run independent work in parallel and coordinate edits to shared files 2. Matt Palmer (@mattyp) - review + publish → Marketing Review (make editorial judgment reusable) > check the draft against the audience and supplied editorial rules Explain substantive edits through: original / revision / rule / rationale > flag unsupported claims. separate required corrections from optional style choices → Social Media Review (control the publishing queue) Slack request → reviewed copy → typefully draft → approval → scheduling > check existing drafts for duplicates. prepare the target account and proposed schedule After Matt’s explicit approval, schedule through Typefully and return: draft_id / scheduled_at / status missing responses stay unresolved. they never count as approval. Save this to improve your agent team ↓

this is f***ng wild SpaceXAI engineer Lauren Tan showed how her agents fix bugs on their own: paste verify-change.prompt into your agent with task / repo / acceptance_criteria Capture the failing case before editing: baseline_revision / environment / inputs / command Before the patch: run the failing scenario and retain logs or traces After the patch: rebuild the changed executable, replay the same scenario and run relevant regression checks record both outcomes. for performance changes, compare baseline and candidate under the same workload Deduplicate before delegating: > use coordinate-reports.prompt to group reports by affected behavior and plausible shared cause > check each problem against current main. keep confirmed findings separate from hypotheses Create one scoped work item per distinct problem: issue / evidence / owner / dependencies / acceptance parallelize independent investigations. coordinate edits that touch shared files Make the lesson executable use encode-lessons.prompt to cluster recurring interventions from agent history and review findings mechanical repetition → script or codemod recurring invalid state → architecture, types, lint or CI work requiring judgment → reusable skill Propose one bounded improvement. include the affected scope, validation evidence and rollback steps tests should catch the failure behavior, not mirror the implementation Save this if you’re tired of supervising every fix ↓

holy f*ck Grok Bot (@bot) engineer Lauren Tan showed her pstack setup for coding agents: request → /poteto-mode → playbook → targeted skills → verification 30 selected skills handle execution. 24 principle references guide design decisions, code quality and failure handling: → 5 startup skills /poteto-mode - routes the task /poteto-help - explains commands and workflows /setup-pstack - configures models and reasoning budget /in-your-own-words - restates the goal before execution /sharpen - strengthens the prompt’s methods and verification → 6 context skills /how - traces implementation /why - investigates design rationale /teach - connects mechanics with reasoning /recall - restores relevant prior context /ketchup - summarizes chat progress and pending decisions /bro - restates the last message without jargon → 4 design skills /architect - defines interfaces, types and boundaries /arena - compares solutions to the same problem /swarm - distributes separate work slices /figure-it-out - designs a playbook when existing ones don’t fit → 7 verification skills /interrogate - challenges the diff across models /tdd - writes a failing test before the fix /benchmark-checklist - checks measurement validity /create-verification-skill - builds runtime checks and a feature map /maintain-verification-skill - updates verification as the app changes /blast-radius - examines impact beyond the diff /show-me-your-work - records a reviewable decision trail → 3 writing skills /unslop - removes generic AI prose /technical-writing - structures technical documentation /no-comments - reviews comments and applies accepted fixes → 5 improvement skills /automate-me - derives a personal mode from work history /reflect - captures completed-work lessons as skill updates /correct - turns recurring mistakes into constraints /make-bot-ui - builds interfaces that trigger Grok Bot through webhooks /typescript-best-practices - applies TypeScript type-system practices + 24 engineering principles cover domain modeling, module boundaries, idempotent operations, behavior-based tests, context management and encoding lessons into project structure Give the router a checkable finish condition: /poteto-mode > reproduce the failure in the running app > define the observable success condition > make the smallest justified fix and repeat the check > return the diff, verification commands, results and blockers the playbook selects the skills. the completion check determines whether the task is done Save this before building another agent workflow from scratch ↓

this must be illegal... SpaceXAI engineer Lauren Tan revealed the skill she uses to automate coding agents: run /create-verification-skill to teach agents how to launch your project, test real features and capture evidence entry point → user actions → observable result Encode that path as a verification record: { "entry_point": { "launch": "exact startup command", "ready": "observable readiness signal" }, "user_actions": { "interface": "UI | CLI | API", "steps": "reproducible actions with fixed inputs" }, "observable_result": { "expected": "checkable outcome", "evidence": "output, file, response or trace" } } Result gate > PASS - executed, expected outcome observed > FAIL - executed, outcome differs > NOT_RUN - blocked or not executed Verify each property against its own evidence: → behavior 1. execute the real CLI / UI / API path with fixed inputs 2. compare expected_output with observed_output 3. read persisted values back from storage → performance compare baseline and candidate profiles control build_config / cache_state / workload record the measured delta and trace paths → code quality > run typecheck / lint / regression_tests > retain command / exit_code / failure_log > keep blocked checks marked NOT_RUN When a failure repeats, use /correct to encode the lesson: architecture → types / lint / CI → regression test → written rule Prefer the strongest enforceable constraint the next agent should encounter a type error, failed check or regression test before the same mistake reaches review Save this for your next verification skill

holy sh*t SpaceXAI (@bot) team showed their agent setup for engineering, design and marketing: Lauren Tan (@poteto) - engineering → Dr. Eggbot audit role boundaries, instructions and missing skills → Matcha split work by dependencies, file ownership and acceptance criteria → Cloud agents implement changes and run checks in the target environment → P Stack evaluate skill revisions with Cursor cloud agents run independent tasks in parallel. coordinate edits to shared files Peng Zheng (@pengzheng_) - design + product → PM + designer + engineer surface constraints and review trade-offs → Figma MCP extend the reference screen using existing components → design-system skill apply consistent typography, colors and spacing → Writer refine voice and language check loading / empty / error / success states before marking the flow complete Matt Palmer (@mattyp) - marketing → Marketing Review revise copy with the applied rule and rationale → Brand Tool Bot retrieve brand assets, materials and presentations → Typefully API + editorial skills prepare copy and proposed posting schedules → Slack routine catch missed requests and duplicate work validate account, timezone and posting time. require approval before live scheduling or publishing. Save this to improve your multi-agent setup