The Strategy Template Builder for StrategyQuant X — Turn a Trading Thesis into a Buildable AlgoWizard Strategy Template

TL;DR

The Strategy Template Builder is a Claude Code skill that turns a trading thesis into a ready-to-import AlgoWizard strategy template — the scaffold the builder fills in as it searches. It reads your SQX installation, designs the entry with real intent (a filter, a trigger, a falsifiable why), wires your groups into a build-confirmed skeleton, and self-validates before you import.

• 🧠 Plain-English thesis in, buildable template out — describe the idea in a sentence.
• 🔍 Reads your install — wires only the random groups you actually have (broken ones excluded automatically).
• 🧩 Designs with intent — assigns filter (when) and trigger (what) roles and writes a falsifiable thesis.
• 🏗️ Proven skeletons, not hand-written XML — stays inside structure that’s already been built and traded.
• 🔁 Long & short mirrored — and the full exit stack is already wired in.
• ✅ Self-validated — groups resolve and every hole is filled before hand-off.

Who this is for

• Strategy builders who want SQX to search inside a coherent structure — filter + trigger + exits — instead of random block combinations.
• Anyone with a library of blocks and groups who wants a clean, buildable template that actually uses them.
• Researchers who want to test a thesis — “breakouts only in the trend” — as a real builder template, fast.
• Anyone who has hand-built a strategy template and watched it fail to build with no obvious reason.

Why it helps

Strategy templates are where the SQX builder’s whole search lives — and they’re also the easiest thing to get subtly wrong:

• Type-correct isn’t the same as buildable. Engine exclusions, MagicNumber wiring, the signal-variable protocol and long/short mirror discipline all live outside the visible schema. A template can look perfectly valid and still refuse to build.
• Knowing which of your groups are usable. A group that references a block you haven’t imported quietly breaks any template that uses it. Spotting that by hand is tedious.
• Designing with intent. A good entry pairs a filter (the regime — when you may act) with a trigger (the event — what fires). Throwing two triggers together is one idea booked twice, not two edges.
• The mirror and the exits. Getting the short side to mirror the long correctly, and wiring a full exit stack (stop, target, trailing, break-even, time exit), is fiddly, repetitive plumbing.

The Strategy Template Builder takes care of all of this. You stay in plain English; it handles the discovery, the design, the proven structure, and produces a clean

.sqx

you import and build.

Core principles

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

1. A template is a strategy with typed holes

A SQX strategy is a typed expression program; a template is that program with some pieces left as holes the builder fills — each hole pointing at one of your random groups. So a template defines the shape of the search; your groups define the menu at each slot. (This is the third skill in the suite: the Custom Block Builder makes the rules, the Random Group Builder pools them, this one wires the pools into a strategy.)

2. Proven skeletons, never hand-written XML

The skill does not hand-write strategy XML from scratch — because in SQX, “type-correct” doesn’t guarantee “buildable.” Instead it transplants your chosen groups into a skeleton that has already been built and traded, and varies only the holes. That keeps every template inside proven-valid territory by construction.

3. It’s install-aware

On first use it reads your installation and lists the clean random groups you can wire — Condition groups as filters/triggers, Value groups as price-level pools. A group that references a missing block is excluded automatically, so a template can’t be built on a broken pool. If you need a pool you don’t have, build it with the Random Group Builder first.

4. Design with intent, with a falsifiable thesis

Before anything is generated, the skill designs the entry like a quant would: pick an archetype, assign a filter and a trigger from your real groups (never two of a kind), pair them for confluence rather than redundancy, choose the execution, and write down why the edge should exist. If you can’t say why, the design is dropped.

5. Long/short mirror and exits are handled

The short side mirrors the long automatically. The full exit stack — stop-loss, profit target, trailing stop, move-to-break-even and time-based exit — is already present in every skeleton; the template just decides which exits the builder may optimize and which stay fixed.

6. Earn it with a Build

Every template self-validates on generation (groups resolve, holes filled), but the final word in SQX is always an actual Build. You import the template and build it — that’s the oracle, and it’s exactly how you’d confirm any template anyway.

Shapes it can design

The generator emits a range of entry structures, all install-wired and mirror-complete:

• Stop entry — a filter + a trigger, entered on a pending stop at a price level.
• Market entry — a filter + a trigger, filled immediately.
• Session-gated — a market entry plus a non-directional time gate (e.g. skip Fridays).
• Multi-timeframe — a higher-timeframe (daily) regime filter combined with a main-chart trigger.
• Role-structured with a veto — regime AND trigger AND NOT veto: trade the setup, but exclude any bar where a spoiler condition also fires.
• Multi-leg — several independent entry legs, each its own group, order type and exit timing.
• Long-only variants of the above, with the short side stripped.

New structures (limit fills, grids, other gates) are added the same earn-it-once way the block and group skills grow: derive a skeleton from a template your install already proves, build-confirm it once, then it generates at scale.

Tutorial — how to use it

Step 0 · One-time setup (per machine)

On first use, the skill asks which StrategyQuant X install to use — point it at the top-level folder (e.g.

D:\SQX_144_…

). It scans your random groups and lists the clean ones you can wire (filters/triggers and price-level pools), excluding any that reference a missing block.

Step 1 · Describe your idea

“Design a trend-filtered breakout template from my install.”
“Make a session-gated momentum entry — no Fridays.”
“Give me three thesis-driven breakout designs and build them.”

You can also hand it a paper or a theme and let it propose designs — each grounded in groups you actually have.

Step 2 · Review and approve the design

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

You approve it, or ask for changes (a market entry instead, a different filter, long-only, a session gate).

Step 3 · It generates and self-validates

Once you approve, the skill wires your groups into the proven skeleton, points each hole at the right group, embeds them, mirrors the short side, and self-validates. It won’t hand you the result unless every group resolves and every hole is filled.

Step 4 · Import and Build in AlgoWizard

You receive a single

.sqx

file plus a short summary. Import it and run a Build:

AlgoWizard → import the template → run a Build.

The builder searches within the template’s structure, drawing from your groups — and the Build is the final confirmation.

Step 5 · If anything needs a tweak

If a template doesn’t build, tell the skill — it fixes the specific shape rather than rewriting everything. The most common cause is a group that points at a block you haven’t imported yet; import the block, regenerate, done.

Bonus: Design & research mode

Don’t have a specific design — just a goal? The built-in design layer proposes thesis-driven templates from your install’s own groups (archetype, roles, a falsifiable why), and an optional research front-end can source edges from the literature, run them through a falsification gate, and feed only the survivors into the design. Everything stays bound to groups you actually have — it never invents a strategy you can’t build.

Part of a bigger toolkit

The Strategy Template Builder is the last 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 into the menus the builder samples from.
• Strategy Template Builder — wire your groups into importable

  .sqx

  strategy templates (this skill).

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 — build 144
• Python 3.8+ — standard library only, no pip installs
• Claude Code with the skill installed
• Random groups in your install to wire (build them with the Random Group Builder if you don’t have any yet)

At a glance

.sqx

FAQ

What’s a strategy template, versus a strategy?

A template is a strategy with the key pieces left as holes the SQX builder fills as it searches — pointing at your random groups. You design the template; the builder explores within it.

Will this work on my version of SQX?

It targets StrategyQuant X build 144. It reads your install and only wires groups you actually have.

Does it invent strategies out of thin air?
No — it only wires the random groups already in your install. If you need a pool that isn’t there, build it with the Random Group Builder first, then wire it.

Why transplant into skeletons instead of just writing the XML?
Because in SQX a template can be perfectly type-correct and still fail to build — the rules that decide buildability live outside the visible schema. Transplanting into a structure that’s already been built keeps every template inside proven-valid territory.

Does it handle long and short, and the exits?
Yes. The short side mirrors the long automatically, and the full exit stack (stop, target, trailing, break-even, time exit) is already wired — you just choose which exits the builder may optimize.

Can it do multi-timeframe or session filters?
Yes — higher-timeframe (daily) regime filters and non-directional time gates (e.g. skip Fridays) are both supported shapes.

Do I still build strategies in AlgoWizard?
You design the template with the skill, then import and Build it in AlgoWizard exactly as you would any template — the Build is the final confirmation.