✦ You asked for this

Free pack · $0

Here is Cross CLI Compatibility Routing. It is free.

A way to organize a big pile of AI agents, skills and workflows so each request goes to the right one, without loading the whole catalog into every call. A PDF guide and a prompt you can hand to your own orchestrator.

Take me to itfree · PDF and prompt
No sign-upNo cardWorks with any orchestrator

✦ Get it

The guide and the prompt

Free, from Joe Che's AI class. A public guide, a direct-download PDF, and a universal migration prompt you can hand to any orchestrator. The PDF holds the architecture, the visible decision tree, the lane rules and the full migration prompt in one clean file.

It audits first. Then it plans.

It does not

  • Start by changing your files. The prompt says audit first
  • Rewrite your whole system at once. It migrates in phases
  • Throw away a working recipe system. It keeps your deterministic lane

It does

  • Inventory what you have: recipes, skills, workflows, agents and helpers
  • Find where context bloat and routing mix-ups come from
  • Lay out a target design and a lane for each capability
  • Give you migration phases, validation rules, test cases and a checklist

✦ The idea

Big capability systems get slower before they get smarter

The failure mode is rarely raw model intelligence. It is almost always architecture: too much context, too many ambiguous surfaces, and no clean authority boundary between deterministic operations and judgment-heavy work. This is not about stuffing more intelligence into the prompt. It is about shrinking the top of the system so the runtime can load only what is necessary.

What this fixes

Without this, more agents and more skills eventually make the system slower, noisier and less reliable. With this, requests get routed by lane, execution stays authoritative, and the top of the stack stays tiny.

The real problem

  • Context bloat: Too many skills, prompts, and helper descriptions get shoved into the top of every session. The model spends context budget on metadata instead of the actual job.
  • Routing ambiguity: Recipes, skills, workflows, and background agents all blur together. The system cannot tell what is deterministic infrastructure and what requires judgment.
  • Discovery failure: Important capabilities exist, but they are buried behind folder structure, naming drift, or inconsistent manifests. The agent misses them until a human points them out.
  • Maintenance drift: As more capabilities are added, aliases sprawl, helper files leak into routing, and nobody can explain why a task was routed one way instead of another.

The architecture: tiny bootstrap first, lane-native execution second

  1. Tiny bootstrap. Start with `ROUTING-SLIM.md` only. This file stays intentionally small. Its only job is to point the runtime toward the global discovery index and the lane-selection rules.
  2. Capability index. Load a compact machine-readable capability registry. The system reads one generated index that lists the routable capability packages across recipes, worker skills, and workflows. It does not load execution docs yet.
  3. Lane selector. Decide what kind of work this request actually is. The selector answers one question first: is this deterministic operational work, ambiguous compositional work, or an orchestration pattern request?
  4. Lane-native execution. Hand off to the authoritative executor for that lane. Recipes stay inside the recipe dispatcher. Worker and skill requests stay inside the adaptive planning runtime. Workflows like Dalio Council stay in the workflow lane.
  5. Normalized output. Return one result envelope to the caller. The top-level router should not care which lane fulfilled the request. The lane systems stay specialized while the outer interface stays clean.

The decision tree

The outer router chooses the lane. The lane system chooses the executor. That is the whole trick.

  1. Incoming request.
  2. Bootstrap: read ROUTING-SLIM.md.
  3. Discovery: load the compact capability index.
  4. Lane selector. Is it deterministic operational work? Route to the recipe lane. Is it a named orchestration pattern? Route to the workflow lane. Otherwise, is it ambiguous or compositional? Route to the worker or skill lane.
  5. Finish: return one normalized result envelope.

Recipe Lane: Deterministic operations

Best for repeatable, validated, code-backed actions. If a task is structured, repeatable, and already modeled as an operational recipe, route into the authoritative recipe dispatcher. Do not flatten recipe semantics into generic skill routing.

  • Recipe manifests stay the source of truth.
  • Dispatcher scoring, validation, precedence, and fallback remain authoritative.
  • Best for operational tasks where reliability matters more than creativity.

Worker / Skill Lane: Ambiguous and compositional work

Best for novel requests, synthesis, and routing uncertainty. This lane handles the work that needs judgment. It can load a selected capability package, compose multiple steps, and explicitly invoke recipes by ID when needed.

  • Only load execution instructions after a capability is selected.
  • Keep discovery coarse and execution rich.
  • Use this lane for planning, synthesis, migration work, and unfamiliar requests.

Workflow Lane: Reusable orchestration patterns

Best for explicit orchestration systems like councils, war rooms, or structured review flows. Some capabilities are not recipes and are not ordinary skills. They are reusable orchestration patterns. They need their own lane so they can be discovered without being misclassified.

  • Model workflows as first-class capabilities.
  • Keep them separate from recipes and ordinary skill payloads.
  • Use this lane when the user is asking for a named orchestration pattern.

Why this scales: it grows by breadcrumbing, not by preloading everything

  • Every call starts with dramatically less global context.
  • Discovery becomes cheaper because the selector reads a compact index instead of a giant prompt dump.
  • Recipes stop getting mislabeled as skills, and workflows stop getting buried as random helpers.
  • The model spends more attention on the request and less on memorizing the catalog.
  • New capabilities can be added without increasing prompt clutter linearly.

Build rules: the system only stays clean if new capabilities enter cleanly

  • Creation rules: Every new routable thing must enter the system through one authoritative metadata source, one immutable ID, one declared lane, and zero hand-edited central registry files.
  • Authority boundaries: Global routing chooses the lane. Lane-native systems choose the executor inside that lane. Recipes keep their dispatcher logic. Workflows keep their orchestration logic.
  • Drift controls: The generated index must be rebuildable, validated, and linted. Non-routable helpers stay out of the index. Routing decisions need explanation output.
  • Growth model: The system should expand by adding a capability package and manifest, not by enlarging bootstrap docs or stuffing more catalog text into every call.

✦ Use it now

Hand this to your orchestrator

This prompt is written to force an audit-first migration. It makes the system inspect what already exists, preserve deterministic infrastructure, and only then restructure toward the lane-based model. Tap Copy, then paste it to your own orchestrator.

Start here · the universal migration prompt

Migrate to lane-based routing

Audit first, plan second, change things only after the plan holds up.

You are the top-level orchestrator for a migration from an ad hoc AI capability system to a lane-based cross-CLI routing architecture.

Your job is to inspect the current system first, then produce a migration plan, then execute only after the plan is internally validated.

Operate conservatively. Do not rewrite the whole system blindly. Preserve working deterministic infrastructure. Remove ambiguity, not capability.

OBJECTIVE

Restructure the current system so it follows this shape:

ROUTING-SLIM.md
-> capabilities index
-> lane selector
-> lane-native execution

The target lanes are:
1. Recipe lane for deterministic, validated, operational execution
2. Worker or skill lane for ambiguous, novel, and compositional work
3. Workflow lane for reusable orchestration patterns

PRIMARY OUTCOME

The migrated system must become:
- smarter at selecting the right capability
- faster at startup and routing
- leaner in context usage
- easier to grow without routing drift
- portable across multiple CLIs or orchestrators

NON-NEGOTIABLE ARCHITECTURE RULES

1. Keep the bootstrap tiny.
ROUTING-SLIM.md must remain a protocol entrypoint, not a catalog dump.

2. Use one generated discovery artifact.
Do not hand-maintain a giant central registry. Build one machine-readable index from authoritative local metadata.

3. Route by lane first.
Do not flatten recipes, worker skills, and orchestration workflows into one undifferentiated selector.

4. Preserve deterministic recipe systems.
If the current system already has a recipe dispatcher, manifest schema, precedence rules, validation logic, or fallback behavior, preserve that lane instead of replacing it.

5. Treat capability packages as the unit.
Do not assume everything is a SKILL.md file. Skills, recipes, workflows, agents, prompts, and tool-backed capabilities may all exist in different forms.

6. Exclude non-routable helpers.
Utility files, helper modules, and implementation details should not appear in the global routing index unless they are intended to be selected directly.

7. Use immutable IDs.
Do not derive stable identity from display names.

8. Prefer deterministic selection before model-heavy selection.
The first pass should use explicit metadata, runtime availability, aliases, and routing rules before loading verbose execution docs.

DISCOVERY PHASE

Before proposing any migration, inspect and classify the current system.

Inventory:
- recipes
- skills
- workflows
- agents
- shared modules
- dispatchers
- helper utilities
- registries
- top-level routing files
- prompt bundles
- direct-download assets
- launch automation surfaces if they are part of the capability lifecycle

For each discovered item, determine:
- what it is
- whether it is directly routable
- whether it is deterministic or judgment-based
- whether it already has an authority boundary
- whether it belongs in recipe, worker or skill, or workflow lane
- whether it is a helper that should be excluded from routing

CURRENT-STATE ANALYSIS

Produce a precise diagnosis of the current architecture:
- where context bloat comes from
- where routing ambiguity comes from
- where recipes and skills are being confused
- where workflows are hidden or mislabeled
- where capability discovery fails
- where helper files are leaking into routing surfaces
- where naming or alias drift is likely
- where central inventory files are overloaded

TARGET MODEL

Design the target system with these layers:

1. Bootstrap
- tiny ROUTING-SLIM.md

2. Discovery
- one generated capability index

3. Lane selector
- recipe vs worker or skill vs workflow

4. Lane-native executor
- authoritative executor inside each lane

5. Normalized result
- one result envelope returned to the caller

CAPABILITY PACKAGE RULES

Define a capability package model that supports:
- one canonical ID
- one authoritative metadata source adjacent to the capability
- one declared lane
- one declared type
- clear routable vs non-routable status

Types may include:
- recipe
- skill
- workflow
- worker-backed capability
- tool-backed capability
- plugin or connector-backed capability

RECIPE LANE RULES

If recipes already exist:
- keep their manifest format authoritative
- keep their dispatcher authoritative
- keep scoring, validation, precedence, and fallback behavior inside that lane
- expose recipes in the global discovery index only for coarse discovery
- do not duplicate recipe semantics into the outer routing layer

WORKER OR SKILL LANE RULES

- select one capability by default
- load rich execution docs only after selection
- allow explicit composition of recipes when necessary
- keep discovery metadata narrow
- keep routing logic centralized rather than embedding complex policy into every capability

WORKFLOW LANE RULES

- treat reusable orchestration patterns as first-class capabilities
- do not force them into recipe or ordinary skill categories
- define when they are directly invokable and when they are internal-only

MIGRATION STRATEGY

Do not migrate everything at once.

Phase the migration:
1. identify top-level routing and overloaded inventory surfaces
2. identify the existing deterministic lane, if any
3. classify high-frequency capabilities first
4. add authoritative metadata to routable capabilities
5. generate the capability index
6. implement lane selection
7. test with real prompts
8. migrate long-tail capabilities gradually

VALIDATION REQUIREMENTS

Add validation for:
- duplicate IDs
- alias collisions
- missing or vague routing metadata
- missing capability paths
- helpers incorrectly exposed as routable
- stale generated index
- lane/type mismatches

TEST REQUIREMENTS

Create tests or fixtures for:
- deterministic operational requests routing to the recipe lane
- ambiguous or novel work routing to the worker or skill lane
- explicit orchestration requests routing to the workflow lane
- important named capabilities resolving correctly by alias
- low-confidence fallback behavior
- exclusion of non-routable helpers

OUTPUT FORMAT

Produce:
1. current-state diagnosis
2. target architecture
3. lane classification table
4. migration phases
5. validation rules
6. test cases
7. implementation checklist

IMPORTANT BEHAVIOR

- Do not start by mutating files.
- Audit first.
- Preserve working deterministic infrastructure.
- Keep the top of the system tiny.
- Expand only as necessary.
- Optimize for portability across different CLIs and orchestrators.
- Optimize for long-term maintainability, not cleverness.

If the current system already contains a dispatcher, giveaway pipeline, registry, workflow runner, or orchestration layer, classify it before changing it.

✦ Get unstuck

Stuck? Find your line.

I am not sure which download I need

The PDF is the guide: the architecture, the decision tree, the lane rules and the full prompt. The prompt file is only the migration prompt, ready to hand to your own orchestrator.

The PDF will not open

Tap Download the PDF again in a normal browser tab. The same ideas, and the full prompt, are also on this page.

I do not know where to give it the prompt

Hand it to your orchestrator: the top-level AI that runs your agents, skills and workflows. The prompt is written to that role. It is meant to work across different CLIs and orchestrators.

Will it change my files right away?

No. The prompt tells the AI to inspect the current system first, produce a migration plan, and only then execute once the plan is validated. It also says not to start by mutating files.

I do not follow the three lanes

The recipe lane is for repeatable, validated, code-backed work. The worker or skill lane is for ambiguous, new or mixed work that needs judgment. The workflow lane is for named orchestration patterns, like a council or a structured review flow.

It is trying to change too much at once

The prompt says not to migrate everything at once. The phases start with the busiest capabilities and leave the long tail for later. Ask it to follow those phases.

None of these fixed it

Email joe@mastermindshq.business. Say which step you were on and paste what you saw.

✦ What next · paid · optional

Want the next step? Get Found on Google and ChatGPT.

$47one payment, no monthly fee
0API keys or paid services
1prompt per step, run by your Claude Code
14day found check: day 1, 7 and 14
Joe Che

You came for one piece of my Claude Code setup. If you have your own website, the next useful job for that setup is getting the site found.

Get your website listed on Google and Bing so people (and ChatGPT) can find you by your name and your service. ChatGPT finds websites mostly through Bing, so we tell Bing about you too. Your own Claude Code does the work on your computer, one prompt at a time.

  • What it does: sets up Google and Bing, your Google Business Profile, posts that answer real customer questions, and a monthly check.
  • What usually happens: your site shows up when people search your name or business name within a few weeks.
  • What it cannot promise: ranking for competitive searches like "best X near me". That takes months of steady posts.
  • You need a website in a folder Claude Code can open, Node.js 20 or newer, and a free Google account. It is not for Squarespace or Wix sites.
$47One payment. No monthly fee. Your own Claude Code runs it, so nobody else needs access to your accounts.
Get the kit$47 · one payment · secure checkout

Not for you? Close this page. Everything above stays free.

Created by Joe Che.

ChatGPT is a trademark of OpenAI. Claude is a trademark of Anthropic. This page is not affiliated with either.