multi-agent-orchestration
Skill8 starsChanged 43 days agoMITView on GitHub
Coordinate complex development tasks using hierarchical agent teams with supervisors, prompt writers, debuggers, and work recorders. Encodes the TDD-with-agents protocol, premature-completion red flags, and cross-agent file-race avoidance.
18 other projects use a version of this.
Adopted by
Most recently taken up by
- mizchi/skillstheir own version, first seen Nov 15, 2026
- pfangueiro/claude-code-agentstheir own version, first seen Nov 8, 2026
- asmamest/Nexus-Skillstheir own version, first seen Nov 1, 2026
- composio-community/opencode-skillstheir own version, first seen Nov 1, 2026
- DevelopersGlobal/ai-agent-skillstheir own version, first seen Oct 25, 2026
- lgzarturo/codeconductortheir own version, first seen Oct 18, 2026
Used with
Projects with it also use prompt-engineering, refactoring and 6 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
kongyo2Skillprompt-engineering
Comprehensive prompt engineering framework for designing, optimizing, and iterating LLM prompts. This skill should be used when users request prompt creation, optimization, or improvement for any LLM task, or when users need help translating vague requirements into effective prompts through collaborative dialogue and iterative refinement.
Also in 4 projects that use this
pproencaSkillrefactoring
Code refactoring best practices based on Martin Fowler's catalog and Clean Code principles. This skill should be used when refactoring existing code, improving code structure, reducing complexity, eliminating code smells, or reviewing code for maintainability. Triggers on tasks involving extract method, rename, decompose conditional, reduce coupling, or improve readability.
Also in 3 projects that use this
mrgoonieSkillcontext-engineering
Master context engineering for AI agent systems. Use when designing agent architectures, debugging context failures, optimizing token usage, implementing memory systems, building multi-agent coordination, evaluating agent performance, or developing LLM-powered pipelines. Covers context fundamentals, degradation patterns, optimization techniques (compaction, masking, caching), compression strategies, memory architectures, multi-agent patterns, LLM-as-Judge evaluation, tool design, and project development.
Also in 4 projects that use this
OpenAISkillobservability
Vercel Observability expert guidance — Drains (logs, traces, speed insights, web analytics), Web Analytics, Speed Insights, runtime logs, custom events, OpenTelemetry integration, and monitoring dashboards. Use when instrumenting, debugging, or optimizing application performance and user experience on Vercel.
Also in 3 projects that use this
BlockSkilldebugging
Debugging guidelines and best practices
Also in 3 projects that use this
Microsoft AzureSkillgit-workflow
Squad branching model: dev-first workflow with insiders preview channel
Also in 4 projects that use this
Other versions18 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 18
- mizchi/skills★ 422same name
- DevelopersGlobal/ai-agent-skills★ 216same name
- roedyrustam/vibes-plug★ 75same name
- VoDaiLocz/kilo-kit-mcp★ 27same name
- composio-community/opencode-skills★ 14same name
- DavidTeju/shared-skills★ 9same name
- pfangueiro/claude-code-agents★ 7same name
- uvwt/agentdock-skills★ 6same name
- javalenciacai/QASkills★ 5same name
- thejordanleopold/claude-code-skills-distilled★ 4same name
8 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository21 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- context/CLAUDE.mdCLAUDE.md
- api-designSkill
- backendSkill
- cavemanSkill
- commitSkill
- evaluator-optimizerSkill
- frontend-design-systemSkill
- interactive-live-testingSkill
- module-planningSkill
- plan-featureSkill
- prSkill
- ralph-loopSkill
- review-boardSkill
- reviewSkill
- systematic-debuggingSkill
- tdd-workflowSkill
- verification-before-completionSkill
- verificationSkill
- work-recordingSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
15 rules. 0 are common, 13 are distinctive, and 2 are very specific to this project.
0
Common
Most of the 14 edited versions we read keep these.
13
Distinctive
This author's own choices. Worth a look.
2
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 12
Use this skill when:
- Distinctive: line 90
Before dispatching any implementation agent (the example below uses a TypeScript toolchain for concreteness.
- Distinctive: line 148
After each significant action:
- Distinctive: line 267
The GREEN agent's acceptance command IS the test command: Do not let the GREEN agent decide what "passing" means.
- Distinctive: line 268
REFACTOR is optional but the test command MUST still pass: If REFACTOR breaks the test, treat it as a regression and re-dispatch debugger …
- Distinctive: line 330
Before accepting any sub-agent "COMPLETE" status, the orchestrator runs these deterministic checks ITSELF (never trusting the agent's …
- Distinctive: line 337
If any check fails, the dispatch is failed.
- Distinctive: line 373
If the debugger cannot resolve, the supervisor reports to the orchestrator
- Very specific: line 380
After 2 consecutive failures on the same WP, /clear and re-plan with a fresh sub-agent context
- Very specific: line 399
If you keep a .claude/rules/ layer, point these at your own files.
- Distinctive: line 415
When a task involves deployment verification or UI testing, use an interactive live-testing skill within the orchestration.
- Distinctive: line 420
If a bug is found, fix it, commit, rebuild, redeploy, and re-test
- Distinctive: line 421
If working, screenshot the evidence and proceed
- Distinctive: line 444
When a live testing agent finds a bug:
- Distinctive: line 446
Commit with a descriptive message referencing the live test
“Common” is measured: kept by at least 6 in 10 of the 14 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Multi-Agent Orchestration Skill
Coordinate complex development tasks using hierarchical agent teams with supervisors, prompt writers, debuggers, and work recorders.
When to Use This Skill
Use this skill when:
- A task requires multiple specialized agents working together
- Work needs parallel execution across different tracks
- Continuous documentation of progress is required
- Error recovery and debugging support is needed
Architecture
┌─────────────────────────────────┐
│ ORCHESTRATOR │
│ (Main Claude, Opus) │
│ │
│ - Reads plan documents │
│ - Dispatches supervisors │
│ - Aggregates final results │
│ - Makes escalation decisions │
│ - Re-runs acceptance commands │
└─────────────┬───────────────────┘
│
┌───────────────────────┼───────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ SUPERVISOR │ │ SUPERVISOR │ │ SUPERVISOR │
│ Track Lead │ │ Track Lead │ │ Track Lead │
│ │ │ │ │ │
│ Owns: WP-01,02 │ │ Owns: WP-03-06 │ │ Owns: WP-10-12 │
└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
│ │ │
┌────┴────┐ ┌────┴────┐ ┌────┴────┐
│ Support │ │ Support │ │ Support │
│ Team │ │ Team │ │ Team │
└─────────┘ └─────────┘ └─────────┘
Support Team per Supervisor:
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│prompt-writer │ │ impl-agent │ │ debugger │ │work-recorder │
│ (haiku) │ │ (sonnet) │ │ (sonnet) │ │ (haiku) │
│ │ │ │ │ │ │ │
│ Generates │ │ Executes │ │ On-call for │ │ Logs all │
│ context-rich │ │ actual work │ │ failures │ │ activities │
│ prompts │ │ packages │ │ │ │ │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘The model assignments shown (haiku for prompt-writer and work-recorder, sonnet for impl-agent and debugger) are a sensible default that puts the cheaper, faster model on the bookkeeping roles and the stronger model on the reasoning roles. [CUSTOMIZE: adjust per your cost and capability budget.]
Agent Dispatch Protocol
Step 1: Supervisor Receives Track Assignment
## Track Assignment: [TRACK_NAME]
### Owned Work Packages
- WP-XX: [description]
- WP-YY: [description]
### Support Team
- prompt-writer: Generate optimized prompts before each dispatch
- [impl-agent]: Execute work packages (backend-impl, frontend-impl, etc.)
- debugger: On-call for error diagnosis
- work-recorder: Continuous progress logging
### Dependencies
- Depends on: [list of prerequisite tracks/WPs]
- Blocks: [list of dependent tracks/WPs]
### Success Criteria
- [ ] All WPs complete
- [ ] Zero compilation errors
- [ ] Work record updated
- [ ] Orchestrator re-ran acceptance command and got exit 0Step 2: Pre-Dispatch Prompt Generation
Before dispatching any implementation agent (the example below uses a TypeScript toolchain for concreteness; the discipline is stack-agnostic, substitute your own type-check, codegen, and test commands):
supervisor -> prompt-writer: "Generate prompt for WP-XX"
prompt-writer -> supervisor: {
"prompt": "[optimized, context-rich prompt]",
"contextFiles": ["path/to/file1.ts", "path/to/file2.ts"],
"planned_files": ["path/to/file1.ts", "path/to/file2.ts"],
"verification": ["npx tsc --noEmit", "your codegen command"],
"forbidden_actions": [
"NO push", "NO work-record edit", "NO destructive ops",
"NO unused imports: import only symbols the code actually references"
],
"estimatedTokens": 800
}planned_files is the declared set of files this agent will modify. The supervisor uses it for race detection (see Cross-Agent Race Avoidance below).
Every tester and implementation (backend-impl / frontend-impl / any domain implementer) dispatch brief MUST explicitly forbid unused imports. An agent that writes import { A, B } from '...' and references only A leaves dead code that a Boy Scout rule and a dead-code detector (for example knip) would flag, and on a strict workspace the unused import can fail lint and break the pre-push gate. Spell it out in the brief, do not assume the agent infers it: "import only symbols this code references; remove any import left unused after the edit." The orchestrator confirms by grepping the diff for imported-but-unreferenced symbols before accepting COMPLETE.
Step 3: Implementation Dispatch
supervisor -> impl-agent: [prompt from prompt-writer]
impl-agent -> supervisor: {
"status": "COMPLETE" | "FAILED",
"filesModified": ["path/to/file.ts"],
"commitSha": "8b1d4a2",
"verificationResult": "PASS" | "FAIL",
"verificationOutputVerbatim": "<stdout/stderr block>",
"error": null | "[error details]"
}commitSha and verificationOutputVerbatim are mandatory artifacts. Reports without them are rejected (see Red-Flag Matrix). [CUSTOMIZE: point this at your own AI-agent engineering rule file if you keep one under .claude/rules/.]
Step 4: Error Recovery
If implementation fails:
supervisor -> debugger: {
"error": "[error message]",
"context": "[what was attempted]",
"files": ["affected files"]
}
debugger -> supervisor: {
"rootCause": "[diagnosis]",
"fix": "[recommended fix]",
"files": ["files to modify"]
}
supervisor -> prompt-writer: "Generate fix prompt based on debugger analysis"
supervisor -> impl-agent: [fix prompt]Step 5: Progress Logging
After each significant action:
supervisor -> work-recorder: {
"event": "task_complete" | "decision" | "error_resolved",
"workPackage": "WP-XX",
"details": {
"filesModified": [...],
"commitSha": "8b1d4a2",
"verification": "PASS",
"duration": "estimated"
}
}Execution Patterns
(The YAML examples below use TypeScript-flavored verification steps for illustration. Replace tsc, the codegen step, build, and the test runner with your stack's equivalents.)
Pattern 1: Sequential Track
Track B - Code Migration:
execution: sequential
work_packages:
- WP-03: # Must complete before WP-04
agent: backend-impl
verify: [tsc, codegen]
- WP-04: # Must complete before WP-05
agent: backend-impl
verify: [tsc, codegen]
- WP-05:
agent: backend-impl
verify: [tsc, codegen, build]Pattern 2: Parallel Track (with planned_files declaration)
Track A - Schema Cleanup:
execution: parallel
work_packages:
- WP-01:
agent: backend-impl
verify: [codegen]
planned_files:
- apps/svc-orders/schema/order.schema
- apps/svc-orders/src/domain/entities/order.entity.ts
- WP-02: # Can run simultaneously with WP-01
agent: backend-impl
verify: [codegen]
planned_files:
- apps/svc-orders/schema/refund.schema
- apps/svc-orders/src/domain/entities/refund.entity.ts
sync_point: # Wait for all to complete
verify: [tsc, build]Pattern 3: Cross-Track Dependency
Track C - Verification:
execution: sequential
depends_on: [Track A, Track B]
work_packages:
- WP-10:
agent: tester
verify: [full_build]
- WP-11:
agent: tester
verify: [integration_tests]Pattern 4: TDD-with-Agents (Red-Green-Refactor)
TDD is the single strongest pattern for agentic coding because each red-to-green cycle gives the agent unambiguous feedback (see the /tdd-workflow skill if you keep one). For orchestrated dispatch, Red-Green-Refactor becomes a verifiable protocol enforceable by the orchestrator via git log inspection.
Track TDD - Feature with Tests First:
execution: strict_sequential
work_packages:
- WP-T1:
phase: RED
agent: tester
output_required:
- file: "*.spec.ts"
- commit_message_pattern: "test(scope): add failing test for <feature>"
- test_output_verbatim: required
verification:
command: "<your test runner> run <path>"
expected_exit: 1 # MUST fail
reject_if: "test file missing OR test runner exits 0"
- WP-T2:
phase: GREEN
agent: backend-impl # or frontend-impl, or any domain implementer
depends_on: [WP-T1]
output_required:
- commit_message_pattern: "feat(scope): implement <feature>"
- test_output_verbatim: required
verification:
command: "<your test runner> run <path>" # same command as WP-T1
expected_exit: 0 # MUST pass now
- WP-T3:
phase: REFACTOR
optional: true
agent: backend-impl
depends_on: [WP-T2]
verification:
command: "<your test runner> run <path>"
expected_exit: 0 # still passing
acceptance:
command: "git log --oneline -3"
pattern_required: "test(.*) .* feat(.*) .*" # R then G visible in historyTDD Dispatch Discipline (R-G-R verification protocol)
- Never let the impl agent write the test for its own code. Dispatch tester first, in its own sub-agent context, with no knowledge of the planned implementation.
- Verify RED before dispatching GREEN. Orchestrator runs the test command and confirms exit 1 with the expected assertion failure (not a syntax error, except for the very first test in a new file).
- The GREEN agent's acceptance command IS the test command. Do not let the GREEN agent decide what "passing" means. Use the exact test-runner invocation.
- REFACTOR is optional but the test command MUST still pass. If REFACTOR breaks the test, treat it as a regression and re-dispatch debugger plus impl.
- The R-G-R commits go into separate file-by-file commits. The test file, the impl file, and any refactor are each their own commit. [CUSTOMIZE: align with your
.claude/rules/git-workflow.mdif you keep one.]
Reference: Anthropic's Claude Code best practices identify TDD as the highest-leverage agentic pattern (https://code.claude.com/docs/en/overview). RL-trained reasoning models are specifically good at code because code has built-in verifiable success conditions.
Work Recorder Integration
See references/logging-and-metrics.md for the work-recorder event-type table and the markdown log-format template it fills in after each significant action (Step 5 above).
Quality Gates
Each work package must pass through quality gates:
┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Prompt │--->│ Impl │--->│ Verify │--->│ Log │
│ Writer │ │ Agent │ │ (tester) │ │ (recorder) │
└─────────────┘ └─────────────┘ └──────┬──────┘ └─────────────┘
│
FAIL? │ PASS?
│ │ │
▼ │ ▼
┌──────────┐ │ Continue
│ Debugger │--┘ to next WP
└──────────┘Premature Completion Red Flags
Production teams report 15-25% of agentic coding tasks complete prematurely when no external loop forces verification (Alibaba Cloud, "From ReAct to Ralph Loop"). The orchestrator MUST reject any sub-agent report containing these patterns and re-dispatch with explicit "produce evidence" instructions.
The Red-Flag Matrix
| Pattern in Report | Why It's a Lie | Required Orchestrator Action |
| "Should work" / "Looks good" / "I believe it works" | No verification ran | Reject; demand the verification command output |
| No commit SHA cited | Nothing was committed | Run git log -1 --oneline; if no relevant commit, reject |
git status not clean at "complete" | Half-staged or unstaged work | Reject; demand clean tree or commit-and-report |
| "Tests pass" with no test output block | Test never ran OR result fabricated | Re-run the test command from orchestrator scope |
New import from @org/* not in package.json | Possible hallucinated package | grep package.json; 19.7% of LLM package suggestions are fabricated (USENIX Security 2025) |
| Cited files not present on disk | Phantom files | ls the cited paths; reject if missing |
| Line numbers beyond file length | Imagined locations | Read file at offset; reject if out of range |
| "I noticed X also needs fixing, so I fixed it too" | Scope creep | Reject extra changes; re-dispatch with original scope only |
New any, @ts-ignore, silent catch | Violates production-grade-code standard | grep diff for these; reject if present |
The package-name and type-suppression rows use TypeScript and npm conventions as concrete examples. Adapt the "hallucinated package" check to your package manager's manifest (for example requirements.txt, go.mod, Cargo.toml, pom.xml) and the type-suppression check to your language's escape hatches.
File-Existence Artifact Requirement (the phantom-file guard)
Phantom files are a named failure mode: a sub-agent reports creating or editing a file that is not on disk, or quotes a line count that does not match reality. To close this, every sub-agent COMPLETE claim that asserts a file was created or modified MUST carry two verbatim artifacts per asserted path:
| Artifact | Command | Proves |
| Existence + metadata | ls -la <path> | The file is actually on disk (not a phantom), with size and mtime |
| Line count | wc -l <path> | The file has real content of the claimed shape, not an empty or truncated stub |
A report asserting a file change WITHOUT both artifacts for that path is narrative-only and is REJECTED on sight, same bar as a missing commit SHA.
The orchestrator MUST re-run ls -la <path> and wc -l <path> ITSELF for every asserted path before trusting the report. The agent's own pasted output is not sufficient: a fabricated report can fabricate the ls/wc block too. The orchestrator re-running the commands from its own scope is the deterministic check; if ls reports "No such file or directory", or wc -l disagrees materially with the agent's claim, the file is a phantom and the dispatch is FAILED.
Detection Rule
Before accepting any sub-agent "COMPLETE" status, the orchestrator runs these deterministic checks ITSELF (never trusting the agent's pasted output):
git log -5 --oneline, does the expected commit appear?- The agent's declared acceptance command, does it exit 0?
git status --porcelain, is the tree clean (or only contains files for the next planned dispatch)?ls -la <path>andwc -l <path>for every asserted file path, does each file exist on disk with the claimed shape? (phantom-file guard above)
If any check fails, the dispatch is failed. Invoke the debugger -> prompt-writer -> impl recovery chain (see Error Recovery Protocol below).
Cross-Agent Race Avoidance Protocol
Parallel dispatch is permitted ONLY when the union of all planned_files across simultaneously-dispatched agents contains no duplicates. The orchestrator MUST verify this before launching the wave.
Always-Serialize List
The following files are ALWAYS serialization points. Never dispatch two agents to modify them in parallel, even if the agents claim disjoint sections. The list below is a starting set of common "central registry" archetypes; [CUSTOMIZE: add any file in your project that is auto-loaded, globally imported, or guarded by a shared pre-commit hook]:
**/container.ts(dependency-injection container; central registry)**/index.ts(barrel exports)**/schema.*(a shared, generated, or root schema file)**/eslint.config.js(or your linter config; lint-staged collapse risk)**/package.json(or your dependency manifest; lockfile races)**/CLAUDE.mdand.claude/rules/*.md(auto-loaded context)docs/workrecords/work-record-YYYY-MM-DD.md(append-only journal; only work-recorder may write, and only via Edit append, never Write; each developer's journal is a separate Always-Serialize entry, never share a file across authors)
planned_files declaration step
Every prompt-writer brief MUST include a planned_files array declaring the files the agent will modify. The supervisor computes the union across all parallel dispatches in the current wave. If the union contains duplicates, or if any file is on the Always-Serialize List and another in-flight agent also lists it, the supervisor serializes the conflicting dispatches.
See references/parallel-dispatch-lessons-learned.md for the worked example (two safe parallel cases and one failure case) that motivated this list, and the running lessons-learned log.
Error Recovery Protocol
Level 1: Agent Self-Recovery
- Implementation agent attempts a fix based on the error message
- Retry limit: 1
Level 2: Debugger Intervention
- Supervisor invokes debugger with full context
- Debugger provides root cause analysis (5-Whys, no edits)
- New prompt generated with fix instructions
Level 3: Supervisor Escalation
- If the debugger cannot resolve, the supervisor reports to the orchestrator
- The orchestrator may: reassign, modify scope, or pause the track
Level 4: Orchestrator Decision
- Orchestrator evaluates cross-track impact
- May adjust dependencies or execution order
- Documents the decision in the work record
- After 2 consecutive failures on the same WP,
/clearand re-plan with a fresh sub-agent context
Metrics Collection
See references/logging-and-metrics.md for the per-supervisor metrics JSON schema.
Integration with Existing Skills
This skill works with the following (rename to match the skills you actually keep):
/commit, after track completion/review, before final commit/debug, extended debugging if needed/verify, comprehensive verification/tdd-workflow, when a work package implements business logic (call this skill from within an orchestrated track using Pattern 4 above)/verification-before-completion, run before accepting any COMPLETE status from a sub-agent (mandatory per the Red-Flag Matrix)/systematic-debugging, invoked by the orchestrator when an agent reports failure OR when the orchestrator's verification command fails on accepted work
Enforced By Rules
If you keep a .claude/rules/ layer, point these at your own files. The skill describes HOW; the rules define MUST.
- An AI-agent engineering rule, encoding the dispatch protocol, the show-your-work rule, and the self-correction loop as a mandatory standard.
- A deterministic-review rule, applying the same evidence bar to any automated review board.
- A context-budget rule, keeping sub-agent prompts under a fixed size (for example 2 KB).
- A TDD-discipline rule, the two-commit minimum that Pattern 4 enforces.
- A git-workflow rule, the file-by-file commit discipline that makes commit SHAs a meaningful artifact.
Example Invocation
See references/example-invocation.md for a worked example showing a full /multi-agent-orchestration invocation end to end.
Interactive Live Testing Integration
When a task involves deployment verification or UI testing, use an interactive live-testing skill within the orchestration. The testing agent follows the See, Decide, Act, Verify loop:
- Navigate to the page via a browser-driving tool (for example Playwright, headless, from the app directory)
- Screenshot and READ the image
- Decide the next action based on what is visible
- If a bug is found, fix it, commit, rebuild, redeploy, and re-test
- If working, screenshot the evidence and proceed
Dispatching a Live Testing Track
Track T - Live UI Testing:
execution: sequential
depends_on: [deployment tracks]
agent: interactive-live-tester
work_packages:
- WP-T1: Setup (port-forwards or local server, verify health)
- WP-T2: Login + navigate to feature pages
- WP-T3: Seed data through UI (forms, dialogs)
- WP-T4: Verify rendering (list, detail, empty, error states)
- WP-T5: Check the data pipeline (DB state, message queue, projector logs)
- WP-T6: Fix bugs found, rebuild, redeploy, retest
artifacts:
- <screenshot output dir>/*.png (screenshot evidence)
- Work record narrative with findingsBug Fix Cycle Within Orchestration
When a live testing agent finds a bug:
- Do NOT escalate to orchestrator, fix it inline
- Commit with a descriptive message referencing the live test
- Rebuild only the affected artifact (disable layer caching if a stale layer caused the bug)
- Redeploy to your environment
- Re-establish any port-forward or tunnel the deploy tore down
- Re-test the same action
- Log the bug in the work record findings table
Common Infrastructure Commands
See references/live-testing-infrastructure-and-gotchas.md for example port-forward, rebuild, and log-inspection commands (container-orchestrator flavored; adapt to your stack).
Gotchas Learned from Production Testing
See references/live-testing-infrastructure-and-gotchas.md for the full table of transferable failure modes from live UI testing.
Lessons Learned (running log)
See references/parallel-dispatch-lessons-learned.md for the full running log of parallel-dispatch successes and failures.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

