agentleFS
Jagoda11Jagoda11/the-jagoda-toolkit/skills/protocol/protocol-brains/SKILL.md

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.

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
  1. Very specific:

    Use subagent_type: "Explore" for all agents.

    line 47
  2. Distinctive:

    After all agents report back, produce a unified briefing:

    line 51
  3. Distinctive:

    Do NOT skip any expert — every perspective matters

    line 91
  4. Distinctive:

    Do NOT add your own analysis — only synthesize what the experts return

    line 92
  5. Distinctive:

    Keep the final briefing actionable, not academic

    line 93

≈ “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.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Protocol Brains

Roster

11 experts. Launch each as a parallel Agent with the persona and task described below.

#ExpertPersona
1Database Expert 1Senior database architect — focus on schema design, query performance, indexing, transactions, and data integrity (SQL or NoSQL)
2Database Expert 2Senior database engineer — focus on migration patterns, data flow design, replication, and connection pooling
3TypeScript Architect 1Senior TS architect — focus on type safety, contract design, Zod schemas, and typed route contract patterns
4TypeScript Architect 2Senior TS architect — focus on service layer design, error handling, and API boundary types
5Legacy Migration ExpertLegacy system migration specialist — understands migration patterns, data export, gradual cutover, and the strangler-fig pattern
6React ArchitectSenior 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.
7Test ExpertSenior 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.
8Monorepo ArchitectMonorepo 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).
9Multiagent Workflow Expert 1AI agent systems expert — focus on agent orchestration, prompt design, and multi-agent reliability
10Multiagent Workflow Expert 2AI agent systems expert — focus on agent pipelines, stage design, and agent-to-agent handoffs
11Orchestration ExpertSystems 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:

  1. Persona: From the roster above — tell the agent who they are and what lens they analyze through
  2. Task: The user's task, verbatim
  3. 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.

  4. 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.

  5. 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:

  1. One command per Bash call — never chain with &&, ||, or ;
  2. No multiline commands — no newlines inside a Bash call. Split into separate calls.
  3. No quotes inside comments — # comments must not contain " or '
  4. Prefer dedicated tools — use Read instead of cat, Grep instead of grep, Glob instead of find/ls
  5. Simple commands only — if a command needs pipes or chains, break it into sequential Bash calls

Download now (ZIP)

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
What did you use it for? e.g. Reviewing pull requests in a Rails app

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.