SQX Authoring Toolkit (sqx-lab) — Four Claude Code Skills That Author Your Blocks, Groups, Templates and Projects

TL;DR

sqx-lab is a Claude Code plugin that bundles four skills covering the whole StrategyQuant X / AlgoWizard authoring chain: custom blocks → random groups → strategy templates → build projects. You describe what you want in plain English; each skill reads your own SQX installation, derives a catalog of what your build actually supports, generates the artifact, and self-validates it before you import. Install once as a plugin — all four skills appear in Claude Code automatically.

• 🧰 One plugin, four skills — the full chain from an atomic rule to a scheduled build project.
• 🗣️ Plain English in, importable XML / .sqx / .cfx out — no hand-written SQX XML, ever.
• 🔍 Install-derived — every skill catalogs your install (your indicators, your custom blocks, your groups) and only uses what’s really there.
• 📁 One-command setup —

  /sqx-setup

  asks for your SQX folder once and bootstraps all four skills against it in one go.

• 🩺 Self-diagnosing —

  /sqx-doctor

  health-checks the whole chain and names exactly what’s broken and how to fix it, including random groups that reference blocks your install doesn’t have.

• ✅ Self-validated — every artifact passes the skill’s own validator before you’re told it’s done.
• 🔗 Composable — each skill’s output is the next skill’s input, or use any one alone.

Who this is for

• SQX users who build their own vocabulary — custom blocks, curated pools, thesis-driven templates — and are tired of the XML plumbing.
• Anyone who has imported a hand-edited block or group and watched it silently break a build.
• Teams who want a repeatable, shareable way to go from “a paper says X” to a running build project.
• Users of any one of the standalone skills who want the whole pipeline installed and updated in one step.

Why it helps

Everything the SQX builder searches through is authored somewhere: the blocks are the words, the groups are the menus, the template is the sentence structure, and the project is the machine that runs the search. Each layer has its own file format, its own hidden buildability rules, and its own ways to fail quietly:

• A block that is type-correct can still be rejected by the builder — the real constraints live outside the visible schema.
• A group that references a block you never imported silently poisons every template that uses it.
• A template can look valid and refuse to build; a project can build but chart the wrong timeframes.
• And all of it is install-specific: what works in one SQX install fails in another with different blocks and indicators.

The toolkit’s answer is the same at every layer: derive a catalog from the actual install, generate only from that catalog, and validate before hand-off. You stay in plain English the whole way.

Core principles

1. One chain, four layers

Block → group → template → project. The Custom Block Builder authors atomic rules; the Random Group Builder pools them into the menus the builder samples; the Strategy Template Builder wires the pools into a buildable strategy scaffold; the Strategy Project Builder wraps templates into a project.cfx with build tasks, data, and analysis wired in. Each output feeds the next — or stands alone.

2. Install-derived, never guessed

On first use, each skill bootstraps a catalog from your installation’s own config: which indicators exist, which custom blocks you have (and their opposites), which groups are clean, which projects can serve as donors. Nothing is generated from memory of “what SQX usually has” — if a key isn’t in your catalog, the skill proposes an equivalent that is.

3. You state your install folder once

/sqx-setup

asks where StrategyQuant X is installed — the top-level folder containing internal/ and user/ — and bootstraps all four skills against it in one run. The path is only stored after it validates as a real SQX install, so pointing at the wrong folder fails loudly instead of silently breaking the other skills. It’s kept in a small per-machine file outside the plugin, so it survives plugin updates and reinstalls. Point at a different install later by running

/sqx-setup

again — all four skills follow.

4. Proven structure, varied content

None of the skills hand-write SQX XML from scratch. Blocks are emitted from a grammar checked against your build; templates are transplanted into skeletons that have already been built and traded; projects are cloned from working donor projects in your install. The skills vary the content, not the load-bearing structure.

5. Validate before you import

Every skill ends with its own validator — key resolution, type contracts, hole-filling, structural checks — and won’t declare success until it passes. The final oracle is still SQX itself (an import, a Build), but the class of “silently wrong” files is caught before it reaches you.

6. When something is off, the doctor says what and why

/sqx-doctor

checks the whole setup in one pass: the Python interpreter, the stored install, each skill’s catalog, and whether the block → group → template → project chain is actually intact. Crucially, it detects broken random groups — groups referencing custom blocks that aren’t in your install. A broken Value group silently disables every build-confirmed strategy shape; the doctor names the group, lists the missing blocks, and the Custom Block Builder’s Repair mode can rebuild them from the group’s own repair manifest.

What’s inside

Tutorial — install and first run

Step 1 · Download the plugin

You need Claude Code and Python 3.8+ (standard library only — no pip installs). Download the sqx-lab zip attached to this article and unzip it — you’ll get a sqx-lab/ folder.

Step 2 · Install the plugin

In Claude Code, add the unzipped folder as a plugin marketplace, install the plugin, and restart:

/plugin marketplace add /absolute/path/to/sqx-lab
/plugin install sqx-lab@sqx-lab

That’s the whole installation — all four skills are now available in every Claude Code session, and Claude picks the right one from what you ask for.

Step 3 · One-time setup: /sqx-setup

Run the setup command and point it at your StrategyQuant X folder — the top-level one (e.g. C:\StrategyQuantX144, the folder containing internal/ and user/):

/sqx-setup

It validates the folder (and refuses anything that isn’t a real SQX install), stores the path once for all four skills, bootstraps each skill’s catalog against your install, and reports what it found — how many indicators, custom blocks, clean groups, and donor projects you have to work with. If anything ever behaves oddly later, run the health check:

/sqx-doctor

It reports the Python interpreter, the install, every catalog, and whether the block → group → template → project chain is actually usable — including any broken random groups and exactly how to repair them.

Step 4 · Ask for what you want, at any layer

You don’t invoke skills by name — just describe the artifact:

“Build me a custom block: close above the upper Bollinger band, with its opposite.”
“Group my breakout blocks into a Condition pool for the builder.”
“Design a trend-filtered breakout template from my install.”
“Make a build project that runs my gold templates on H1 with a daily regime chart.”

Each skill follows the same rhythm: it clarifies only what it can’t infer, shows you a plain-English spec first (the cheapest place to catch a wrong design), generates only after you approve, validates, and hands you the file with a short summary.

Step 5 · Import into SQX — that’s the final oracle

Blocks and groups import into AlgoWizard; templates import and Build; projects deploy into your install and run. If SQX rejects something, tell the skill what happened — it fixes the specific artifact rather than regenerating everything. The most common cause is a referenced block that isn’t imported yet in that install.

Step 6 · Compose the chain

The real payoff is the pipeline: author a handful of blocks from a paper → pool them into themed groups → wire the groups into two or three thesis-driven templates → wrap the templates into one project and let it build overnight. Every step stays inside what your install can actually do, because every step reads the same catalog chain.

Updating

Download the latest zip and reinstall the plugin from the marketplace. Your stored install path lives outside the plugin, so it survives the update — just run

/sqx-setup

once afterwards to rebuild the derived catalogs against your install. It takes seconds and confirms everything is intact.

Requirements

• StrategyQuant X / AlgoWizard — build 144
• Python 3.8+ — standard library only, no pip installs
• Claude Code — with the sqx-lab plugin installed (Steps 1–2 above)
• Your own SQX install to point the skills at — everything is derived from it

FAQ

Do I need all four skills?
No. Each works standalone — install the plugin and use only the layer you need. They just get better together, because each one’s output is the next one’s input.

Will it work on my version of SQX?
It targets StrategyQuant X build 144. Because everything is derived from your install, it uses only what your build actually supports.

Does it send my strategies or data anywhere?
The engines are local Python scripts (standard library only) reading your local install. The catalogs and your install path are per-machine files — they never leave your computer.

What if a generated file doesn’t import or build?
Tell the skill what SQX said. Each skill fixes the specific artifact — usually a referenced block that isn’t imported in that install yet — rather than starting over. If several things seem off at once, run

/sqx-doctor

first: it pinpoints whether the problem is the install path, a stale catalog, or a broken group, and tells you the exact command that fixes it.

You know me as clonex. I’m Ivan Hudec — I built the free blocks you’re using here, and I write about the research behind them at algotrading.space. Need something built? Work with me.