The Custom Block Builder for StrategyQuant X — Describe a Trading Rule in Plain English, Get an Import-Ready AlgoWizard Block

Tell it your idea in one sentence — “go long when RSI reclaims oversold” or “a trailing stop two ATRs under the Hull moving average” — and it builds a finished, validated custom block from the indicators your own StrategyQuant X install actually has. You import it into AlgoWizard and it’s ready to use.

TL;DR

The Custom Block Builder is a Claude Code skill that turns a plain-English trading idea into a ready-to-import AlgoWizard custom block. It reads your SQX installation, learns exactly which indicators you can build with, assembles the block for you, and validates it before you import — so it binds correctly the first time.

• 🧠 Plain-English in, working block out — describe the rule in a sentence.
• 🔍 Reads your install — builds only from indicators your machine truly has.
• 🧱 Two block types — true/false signals and price levels (stops, targets, bands, breakout anchors).
• ✅ Validated before import — no more blocks that silently fail to bind.
• 🛡️ Edge-checked — flags look-ahead, repainting and dead thresholds before they cost you in a backtest.
• 🔁 Long & short auto-paired — one idea, both directions.
• 🎛️ Optimizer-ready — every tunable exposed as a proper SQX optimization knob.

Who this is for

• Strategy builders who want to add lots of custom signals quickly, without clicking through the block editor condition by condition.
• Discretionary traders crossing into algo who have a rule in their head but aren’t sure which AlgoWizard indicators or settings map to it.
• Researchers who read a paper or a blog and want to test its signal in SQX fast.
• Anyone who has built a block, hit import, and watched it fail to bind with no clear reason why.

Why it helps

Building custom blocks in AlgoWizard’s interface works well — but as your ideas get more specific, a few things slow you down:

• Knowing what your install can actually do. Every SQX setup is different: your native indicators, your registered customs, the snippets you’ve coded. It’s easy to reach for an indicator that simply isn’t available in your build.
• Getting the details right. Each oscillator has its own midline — RSI 50, CCI 0, Momentum 100, Williams %R −50, Stochastic 50, DeMarker 0.5. Compare against the wrong one and your logic is quietly inverted.
• Multi-output indicators. MACD, Stochastic, Aroon and Ichimoku return several lines — you have to pick the right one.
• Price levels, not just signals. Stops, targets, bands and breakout anchors are a different kind of block — an anchor ± k·ATR here, a confluence of levels there. Hand-wiring them is fiddly.
• Volume. Translating many ideas into many blocks, both long and short, is repetitive work.
• Silent failures — two kinds. A block can look fine yet fail to bind on import; worse, it can import perfectly and quietly lose money because it peeks at the developing bar or uses a repainting indicator. Both eat time and trust.

The Custom Block Builder takes care of all of this. You stay in plain English; it handles the discovery, the details, the safety 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. It’s install-aware

The skill makes no assumption about your SQX version or indicator set. On first use it reads your installation and builds a catalog of every atom you can actually use. Everything it offers you is something your machine can genuinely build — never a “phantom” indicator that exists on someone else’s setup but not yours.

2. It finds your custom indicators — four ways

This is the part that fixes the classic “it didn’t find my indicator!” problem. The skill resolves four sources so every indicator you own is covered, whatever state it’s in:

• Registered in AlgoWizard — read straight from your config, identified by SQX’s own custom marker. This works with or without the

  .java

  source on disk, which is what fixes “it didn’t find my indicator” on a second machine.

• Proven — any custom you’ve already used in a block is harvested in its known-good form.
• Coded but not yet registered — read directly from your indicator’s

  .java

  snippet, so even an indicator you wrote but never registered is found.

• Synthesized — reconstructed from your custom-indicator registry as a best-effort fallback, and flagged “verify on first import”.

Your own indicators are always surfaced by name in a dedicated ⭐ section — never silently mixed into the native list.

3. It builds two kinds of blocks

AlgoWizard has two block types, and the skill authors both. Condition blocks answer a yes/no question (an entry, exit or filter signal). Price-level blocks return a price — a stop, target, band, breakout reference or trailing level — and can be built from a single anchor, an anchor ± k·ATR buffer, or a max/min confluence of several levels. Just say which one you want; the skill picks the right shape.

4. Plain-English first, build second

Nothing is generated until you’ve seen and approved a plain-English spec: the block name, a one-line description, the operator shape (cross / level / rising / percentile / count / arithmetic), the indicators it’ll use, and the parameters with their defaults and ranges. You approve or redirect — then it builds.

5. Validated before you import

The skill checks its own output before declaring it done: multi-output indicators carry the correct line, parameters are properly declared, naming is safe, and risky atoms (e.g. TA-Lib in a single-symbol / FX project, which can crash the build) are blocked. Success isn’t reported until every check passes.

6. Edge-checked, not just syntax-checked

Importing cleanly isn’t the same as trading soundly. On top of the import checks, the skill runs an edge-hygiene pass that grades each block and flags the silent profit-killers a syntax check can’t see: look-ahead on the still-forming bar, repainting indicators read before they’re confirmed, and thresholds set outside an indicator’s range (so the block could never fire). Validation proves the block imports; this proves it won’t quietly lose money.

7. One block = one idea

By default it builds clean, single-signal blocks — one clear idea per block — rather than stacking confirmations together. That keeps your blocks readable, reusable, and easy to optimize. (You can always ask for combined conditions when you genuinely want them.)

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 builds your catalog and shows you your own custom indicators by name, so you can confirm nothing was missed. You only do this once.

Step 1 · Describe your rule

“Go long when RSI comes back up through the oversold level, and short on the mirror image.”

…or ask for a price level instead:

“Build me a trailing stop two ATRs under the Hull moving average.”

You can also hand it a paper, a blog post, or a URL and let it extract the rule for you. If you don’t say otherwise, it assumes sensible defaults (both directions, reasonable parameter 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 (different level, long-only, wider ranges, a different indicator).

Step 3 · It generates, validates and edge-checks

Once you approve, the skill builds the block, selects the correct lines for any multi-output indicators, exposes every tunable as an optimization knob, auto-pairs the long and short sides, and runs both its validator and its edge-hygiene check. It won’t hand you the result until the checks pass — and if the edge check finds a look-ahead or repaint problem, it fixes the block and re-checks before handing it over.

Step 4 · Import into AlgoWizard

You receive a single file plus a short summary table (block → plain-English rule → parameters). Import it:

AlgoWizard → Custom Blocks → Import → select the file.

Your blocks appear in the editor, ready to drop into a strategy and optimize like any other block.

Step 5 · If anything needs a tweak

If a block doesn’t behave as expected after import, tell the skill — it fixes the specific block rather than rebuilding everything. Indicators flagged “verify on first import” (the synthesized ✎ ones) just need a quick check; there’s also a one-step way to upgrade them to fully “proven.”

Bonus: Research mode

Don’t have a specific rule yet — just a theme? Hand the skill something like “find me momentum filters” or a research paper, and it works propose → critique → author: it proposes catalog-grounded, buildable specs (name · rule · confidence · source), then an adversarial critic kills the weak, overfit, repainting or duplicate ideas before any are built. You pick from the survivors, and it authors them through the same flow above. Every suggestion is checked against your catalog, so it never proposes an indicator you don’t have.

Part of a bigger toolkit

The Custom Block Builder is the first 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 (this skill).
• Random Group Builder — pool your blocks into the random groups the strategy builder samples from.
• Strategy Template Builder — wire those 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

Does it work with the Stock Picker engine?

No — as of now it supports only the standard engines in StrategyQuant. Stock Picker support will be added later.

Will this work on my version of SQX?

Yes — that’s the point. It reads your install and only offers atoms you actually have.

Can it build stops, targets and price levels, or only signals?
Both. Alongside true/false signal blocks it authors price-level blocks — stops, targets, bands, breakout anchors and trailing levels — including anchor ± k·ATR buffers and max/min confluence levels.

Do I still build blocks in AlgoWizard?
You build them with the skill and then import the result into AlgoWizard, where they work exactly like any block you’d create in the editor — ready to drop into strategies and optimize.

What if it can’t find one of my custom indicators?
It resolves four sources — registered, proven, coded-but-unregistered, and synthesized — so in practice it finds them all. Synthesized ones are flagged “verify on first import.”

How does it stop me building a block that looks ahead or repaints?
Every block goes through an edge-hygiene check that flags look-ahead on the developing bar, repainting indicators read unconfirmed, and thresholds outside an indicator’s range — and fixes them before hand-off. It’s the difference between a block that imports and one that actually trades soundly.

Can it build both long and short at once?
Yes — long/short pairs are generated together and correctly cross-linked.

I don’t have a specific rule — just a theme.
Use research mode: hand it a theme or a paper and pick from the buildable specs it proposes — after an adversarial critic has weeded out the weak ones.