protocol-brains
Skill0 starsChanged 6 months agoMITView on GitHub
Protocol Brains — 11-expert backend/architecture panel. 2 Database, 2 TypeScript architects, 1 Legacy Migration, 1 React, 1 Test, 1 Monorepo, 2 Multiagent workflow, 1 Orchestration.
In this repository14 other files it gives its agents.
- auditSkill
- promptSkill
- protocol-pinkySkill
- protocolSkill
- review-ai-compatSkill
- review-authSkill
- review-cicdSkill
- review-designSkill
- review-monorepoSkill
- review-prSkill
- reviewSkill
- review-test-strategySkill
- startSkill
- start-uiSkill
The file
We split this skill into the rules it gives an agent
5 rules. About 0 are common, 4 are distinctive, and 1 is very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈4
Distinctive · estimate
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 47
Use subagent_type: "Explore" for all agents.
- Distinctive: line 51
After all agents report back, produce a unified briefing:
- Distinctive: line 91
Do NOT skip any expert — every perspective matters
- Distinctive: line 92
Do NOT add your own analysis — only synthesize what the experts return
- Distinctive: line 93
Keep the final briefing actionable, not academic
≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Protocol Brains
Roster
11 experts. Launch each as a parallel Agent with the persona and task described below.
| # | Expert | Persona |
| 1 | Database Expert 1 | Senior database architect — focus on schema design, query performance, indexing, transactions, and data integrity (SQL or NoSQL) |
| 2 | Database Expert 2 | Senior database engineer — focus on migration patterns, data flow design, replication, and connection pooling |
| 3 | TypeScript Architect 1 | Senior TS architect — focus on type safety, contract design, Zod schemas, and typed route contract patterns |
| 4 | TypeScript Architect 2 | Senior TS architect — focus on service layer design, error handling, and API boundary types |
| 5 | Legacy Migration Expert | Legacy system migration specialist — understands migration patterns, data export, gradual cutover, and the strangler-fig pattern |
| 6 | React Architect | Senior React architect — focus on component design, state management, form patterns (e.g., react-hook-form / Formik), and server-state caching (e.g., TanStack Query / SWR / Apollo Client). Detect which libs the project uses from package.json and review against those. |
| 7 | Test Expert | Senior test engineer — focus on test strategy, coverage gaps, test framework patterns (e.g., Vitest / Jest / Mocha), mocking, and integration tests. Detect which framework the project uses from package.json and review against its conventions. |
| 8 | Monorepo Architect | Monorepo specialist — focus on workspace boundaries, dependency direction (no cycles), build orchestration and caching (e.g., Turborepo / Nx / pnpm workspaces / Yarn workspaces), shared package design, workspace protocol usage (workspace:*), and tsconfig project references. Detect which tool the project uses from root config (turbo.json / nx.json / pnpm-workspace.yaml / package.json workspaces). |
| 9 | Multiagent Workflow Expert 1 | AI agent systems expert — focus on agent orchestration, prompt design, and multi-agent reliability |
| 10 | Multiagent Workflow Expert 2 | AI agent systems expert — focus on agent pipelines, stage design, and agent-to-agent handoffs |
| 11 | Orchestration Expert | Systems orchestration expert — focus on pipeline sequencing, error recovery, parallel execution, and workflow design |
Instructions
Step 1 — Receive Task
The task comes from the user's input (passed as arguments). This is what ALL experts work on.
Step 2 — Launch Experts in Parallel
Spawn all 11 agents in parallel using the Agent tool. Each agent gets:
- Persona: From the roster above — tell the agent who they are and what lens they analyze through
- Task: The user's task, verbatim
- Context and tool priority (include VERBATIM in every agent prompt):
This is the some-git-repo monorepo. A CodeGraph index exists. ALWAYS use CodeGraph tools FIRST: codegraph_search to find symbols, codegraph_callers/codegraph_callees to trace flow, codegraph_context for broad understanding, codegraph_node to read source. Only fall back to Grep for string literals or comments not in the graph. Never use grep/cat/find via Bash — use Grep, Read, Glob tools instead.
- CRITICAL Bash rules (include this VERBATIM in every agent prompt):
BASH RULES: Never use grep/cat/find/head/tail via Bash — use the Grep, Read, Glob tools instead. Never chain commands with && || or ;. Never put quotes inside # comments. One simple command per Bash call. Break complex commands into multiple sequential calls.
- Output format: Each agent must return:
- Assessment: What they found (3-5 bullet points max)
- Risks: Any concerns from their domain perspective
- Recommendations: Concrete next steps
Use subagent_type: "Explore" for all agents. Set model: "sonnet" to maximize parallel throughput.
Step 3 — Synthesize
After all agents report back, produce a unified briefing:
## Protocol Brains — Briefing
**Task**: <the task>
### Expert Reports
#### Database (2 experts)
<merged findings>
#### TypeScript Architecture (2 experts)
<merged findings>
#### Legacy Migration
<findings>
#### React Architecture
<findings>
#### Test Strategy
<findings>
#### Monorepo Structure
<findings>
#### Multiagent & Orchestration (3 experts)
<merged findings>
### Consensus Risks
<risks that multiple experts flagged>
### Recommended Actions
<prioritized list of concrete next steps>Constraints
- Launch ALL 11 agents in a single message (maximize parallelism)
- Do NOT skip any expert — every perspective matters
- Do NOT add your own analysis — only synthesize what the experts return
- Keep the final briefing actionable, not academic
Bash Command Rules (IMPORTANT — include in every agent prompt)
Agents MUST follow these rules when writing Bash commands to avoid interactive approval prompts:
- One command per Bash call — never chain with
&&,||, or; - No multiline commands — no newlines inside a Bash call. Split into separate calls.
- No quotes inside comments —
#comments must not contain"or' - Prefer dedicated tools — use
Readinstead ofcat,Grepinstead ofgrep,Globinstead offind/ls - Simple commands only — if a command needs pipes or chains, break it into sequential Bash calls
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.

