sqx-lab: Four AI Skills That Author Your StrategyQuant Building Blocks, Groups, Templates and Projects

Everything the StrategyQuant builder searches through is authored somewhere. The custom blocks are the words, the random groups are the menus, the template is the sentence structure, and the build project is the machine that runs the search. For years I authored all of that by hand — and if you have ever hand-edited SQX XML, you know each layer has its own file format, its own hidden buildability rules, and its own ways to fail quietly.

Today that whole authoring chain is one installable plugin. sqx-lab — the SQX Authoring Toolkit — bundles four Claude Code skills covering the full chain: custom blocks → random groups → strategy templates → build projects. You describe what you want in plain English; each skill reads your own StrategyQuant X installation, derives a catalog of what your build actually supports, generates the artifact, and self-validates it before you import. It is free, and it is downloadable from the StrategyQuant Codebase.

This is the “vocabulary” half of the agentic strategy development framework I wrote about in July — now packaged so you can install it once and use it in every Claude Code session.

In the interest of full disclosure: the StrategyQuant links in this article are affiliate links — if you start there through them I may earn a commission, at no extra cost to you. The plugin itself is, and will remain, free.

Why authoring needed fixing

Each layer of the SQX vocabulary can fail silently:

A custom block that is type-correct can still be rejected by the builder — the real constraints live outside the visible schema.
A random 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. 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.

What’s inside

Skill	Authors	Feeds into
sqx-custom-block	atomic trading rules — Condition blocks (true/false signals) and Price-level blocks (stops, targets, bands) — as importable custom-block XML	groups
sqx-random-group	the pools the builder samples from — Condition groups (rule menus) and Value groups (price/level menus), from your existing blocks or fresh inline atoms	templates
sqx-strategy-template	full .sqx strategy templates with typed holes bound to your clean groups — filter + trigger design, full exit stack	projects
sqx-strategy-project	build projects (project.cfx) that wire your templates in as build tasks — data, timeframes, multi-timeframe charts, custom analysis	—

Each skill works standalone, but 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.

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.

Setup is one command now

The latest release (1.2) rebuilt onboarding around two commands:

/sqx-setup asks for your StrategyQuant X folder once — the top-level one containing internal/ and user/ — and bootstraps all four skills against it in a single 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 outside the plugin, so it survives updates and reinstalls.

/sqx-doctor is the health check: it reports the Python interpreter in use, the stored install, every 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 entire classes of strategy shapes; 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.

That last part matters more than it sounds. “It generated something and SQX rejected it” is a fixable afternoon. “One stale group has been quietly excluding half my templates for a month” is the kind of failure you never notice — and now there is a command that names it.

How you actually use it

You don’t invoke skills by name — you 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. Blocks and groups import into AlgoWizard; templates import and Build; projects deploy into your install and run.

The final oracle is still StrategyQuant itself: an import, a Build. But the class of “silently wrong” files is caught before it reaches you. And if SQX does reject something, you tell the skill what happened — it fixes the specific artifact rather than regenerating everything.

Getting it

Everything runs locally: the engines are plain Python scripts (standard library only, no pip installs) reading your local install. Your catalogs, your install path, your strategies — nothing leaves your machine.

You need:

StrategyQuant X — build 144
Claude Code with any paid Claude plan
Python 3.8+

Download the plugin zip from the StrategyQuant Codebase, unzip it, and install it in Claude Code:

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

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

Vocabulary vs. sentence

A fair question: how is this different from the strategy builder I’ve written about, the one that turns one sentence into a finished .sqx?

The toolkit authors the reusable vocabulary — blocks, pools, templates, projects — that the SQX builder then searches through. The strategy builder produces one finished strategy from an idea. Vocabulary vs. sentence. Use the toolkit to shape what your searches can find; use the builder when you want one concrete strategy now. They are designed to feed each other, and both are part of the same agentic framework — an AI proposes, but nothing is trusted until StrategyQuant itself accepts it.

If you build systematic strategies and you’ve ever lost an evening to hand-edited XML, this is the tool I wish I’d had a decade ago. Grab it from the Codebase, and if you build something interesting with it — tell me about it.