The Random Group Builder for StrategyQuant X — Pool Your Blocks into the Menus the Strategy Builder Samples From

TL;DR

The Random Group Builder is a Claude Code skill that turns “pool these” into a ready-to-import AlgoWizard random group — the curated menu the strategy builder draws one item from per strategy to fill a slot. It reads your SQX installation, learns which blocks and atoms you can pool, assembles the group, and validates it before you import.

• 🧠 Plain-English in, working group out — describe the pool in a sentence.
• 🔍 Reads your install — pools only from blocks and atoms your machine truly has.
• 🧱 Two group types — Condition (boolean rule pools) and Value (price / level / number pools).
• 🔗 Two ways to fill — hybrid (re-export your existing custom blocks by reference) or inline (fresh atoms).
• 🎛️ Optimizer-correct — each knob frozen, optimized over its own range, or set to a range you choose.
• ✅ Validated before import — type-checked, key-checked, flat-item-checked.

Who this is for

• Strategy builders who want the builder to explore a curated set of entries, filters or levels for a slot — instead of the global block soup.
• Template builders who need Same condition / Same value pools to bind into a strategy template.
• Researchers who want to A/B a whole family of related signals or levels in a single build.
• Anyone who has assembled a random group in the UI, item by item, and didn’t enjoy it.

Why it helps

Building random groups in AlgoWizard’s interface works well — but as your pools get bigger and more specific, a few things slow you down:

• Knowing what your install can pool. Your blocks, your registered customs, the native atoms — every SQX setup is different. It’s easy to reach for a block or atom that isn’t in your build.
• The optimizer model is subtle. Each parameter can be frozen, optimized over its own range, or given an explicit min:max:step. Get it wrong and a knob is either dead or searching nonsense.
• Type contracts. A Condition group needs boolean items; a Value group needs price/number items. Mix them and the group misbehaves.
• Flat-item rule. A group item is one rule or one comparison — AND/OR logic belongs in a custom block, not in a group. Easy to trip over.
• Volume. Adding many items, across many pools, by hand is repetitive work.

The Random Group Builder takes care of all of this. You stay in plain English; it handles the discovery, the optimizer details, the type checks, and produces a clean file you import straight into AlgoWizard.

Core principles

A few ideas underpin how the skill works — understanding them helps you get the most out of it.

1. A group is a menu, not a rule

A random group is a curated set the builder draws ONE item from per strategy, to fill a single slot — overriding the global Building-Blocks settings for that slot. A strategy template binds it to a placeholder (Same condition for a Condition group, Same value for a Value group). So a group is a shortlist of alternatives, while a block is the rule. (Sibling skill: the Custom Block Builder builds the blocks; this one pools them.)

2. It’s install-aware

The skill makes no assumption about your SQX version or block library. On first use it reads your installation and builds a catalog of everything you can pool — your

CBlock_*

custom blocks (listed by name) plus the native rule and value-atom templates. Everything it offers is something your machine can genuinely build — never a “phantom” block from someone else’s setup.

3. Two group types — Condition and Value

Condition groups pool boolean rules — entry triggers, exit signals, regime filters. Value groups pool prices and numbers — stop/target levels, band lines, comparison operands. The skill picks the right type from what you describe and enforces it on every item.

4. Two ways to fill a pool — hybrid and inline

Hybrid (the common case) re-exports your existing custom blocks by reference — most real groups are just a thin index into your block library. Inline builds fresh items from catalog atoms: a boolean rule, a bare value atom, or one operator comparison (

Close > EMA

,

RSI < 30

). You can mix both within a set.

5. The optimizer model is built in

Every tunable is handled correctly by construction: frozen (a fixed value), optimized over the atom’s own sensible range, or given an explicit min:max:step you choose. No more guessing whether a knob is live or inert.

6. Plain-English first, build second

Nothing is generated until you’ve seen and approved a plain-English spec: the group name, its type, the mode, the items it’ll contain, and which knobs are optimized. You approve or redirect — then it builds.

7. Validated before you import

The skill checks its own output before declaring it done: every key exists in your catalog, every item’s type matches the group, items are flat (no smuggled AND/OR), and the XML root is correct. Success isn’t reported until every check passes.

Tutorial — how to use it

Step 0 · One-time setup (per machine)

On first use, the skill asks where StrategyQuant X is installed — point it at your top-level folder (e.g.

C:\StrategyQuantX144

). It reads your config and your custom-blocks file, then shows you your poolable blocks by name, so you can confirm nothing was missed. You only do this once.

Step 1 · Describe your pool

“Make me a Condition group that pools my breakout blocks.”
“Build a Value group of EMA, KAMA and ATR-band levels.”
“Pool RSI<30, Momentum-rising and Close-above-EMA into a filter group.”

You can also hand it a paper, a blog post, or a URL and let it extract the rules for you. If you don’t say otherwise, it assumes sensible defaults (5–8 items, knobs optimized over their own ranges).

Step 2 · Review and approve the spec

The skill replies with a plain-English spec for you to check:

You approve it, or ask for changes (a Value group instead, inline rather than hybrid, fewer items, a frozen knob).

Step 3 · It generates and validates

Once you approve, the skill builds the group, references your blocks (hybrid) or assembles fresh items (inline), sets each knob’s optimizer state, gives the group a fresh UUID, and runs its validator. It won’t hand you the result until all checks pass.

Step 4 · Import into AlgoWizard

You receive a single file plus a short summary table (group → type → items). Import it:

AlgoWizard → Building-block / random groups → Import → select the file.

Your groups appear ready to bind to a template slot, and the builder starts sampling one item per strategy.

Step 5 · If anything needs a tweak

If a group doesn’t behave as expected after import, tell the skill — it fixes the specific group or item rather than rebuilding everything. A hybrid item that won’t resolve usually just means its block isn’t imported in that install yet — import the block first.

Bonus: Research mode

Don’t have a specific pool in mind — just a theme? Hand the skill something like “a pool of trend filters” or a research paper, and it proposes catalog-grounded, buildable items (rule · source), pulling from your own blocks where they fit. You pick what you like, and it authors the group through the same flow above. Every suggestion is checked against your catalog, so it never proposes a block or atom you don’t have.

Part of a bigger toolkit

The Random Group Builder is the middle of a three-skill pipeline that mirrors how a strategy is actually composed — build the rules → pool them → wire them into a strategy:

• Custom Block Builder — author the individual signals and price levels.
• Random Group Builder — pool those blocks (and fresh atoms) into the menus the builder samples from (this skill).
• Strategy Template Builder — wire your groups into importable

  .sqx

  strategy templates bound to your own install.

Each one is install-aware and works the same plain-English way. Use them on their own, or as a pipeline.

Requirements

• StrategyQuant X / AlgoWizard
• Python 3.8+ — standard library only, no pip installs
• Claude Code with the skill installed

At a glance

FAQ

What is a random group, and how is it different from a block?

A block is a rule; a group is a menu the builder draws one item from per strategy, to fill a single slot. You build blocks with the Custom Block Builder, then pool them with this skill.

Will this work on my version of SQX?

Yes — it reads your install and only pools blocks and atoms you actually have.

Condition group or Value group — which do I need?
Condition for boolean rule pools (triggers, filters, exits); Value for price/number pools (stops, targets, band levels, comparison operands). The skill picks from what you describe and enforces it.

Hybrid or inline?
Hybrid re-exports your existing custom blocks by reference — the common case. Inline builds fresh items from native atoms (a rule, a value, or one comparison). You can mix both in a set.

Can I put AND/OR logic inside a group item?
No — group items are flat (one rule / one comparison). Compound logic belongs in a custom block; build it there, then pool it via hybrid.

Do I still build groups in AlgoWizard?
You build them with the skill and then import the result, where they behave exactly like a group you’d assemble in the UI — ready to bind to a template slot and optimize.

Which knobs get optimized?
By default the period/double knobs are optimized over their own sensible ranges; you can freeze any of them, or set an explicit min:max:step.