Transforms a plain-English trading thesis into a buildable strategy template. Reads your install, designs entry logic with intent, wires your groups into a proven skeleton, and self-validates.
The Strategy Template Builder for StrategyQuant X
TL;DR
Turns a trading thesis into a ready-to-import AlgoWizard strategy template. Reads your SQX installation, designs entries with filter + trigger intent, wires your groups into a build-confirmed skeleton, and validates before hand-off.
• Plain-English thesis in, buildable template out
• Reads your install — wires only groups you have
• Designs with intent — assigns filter (when) and trigger (what) roles
• Proven skeletons, not hand-written XML
• Long & short mirrored; full exit stack already wired
• Self-validated before import
Who this is for
• Strategy builders who want coherent structure (filter + trigger + exits) instead of random blocks
• Anyone with a library of blocks and groups wanting a clean template that uses them
• Researchers testing a thesis as a real builder template
• Anyone whose hand-built templates fail to build with no obvious reason
Why it helps
Type-correct templates aren't always buildable — engine exclusions, MagicNumber wiring, and signal-variable protocol live outside the schema. The skill handles group validation (broken groups excluded automatically), pairs filters with triggers for confluence, designs with falsifiable intent, and manages the mirror and full exit stack.
Core principles
Templates are strategies with typed holes — the builder fills them from your random groups. Proven skeletons only — transplants groups into structures already built and traded, staying inside valid territory. Install-aware — lists clean random groups at startup; excludes those referencing missing blocks. Design with intent — picks archetype, assigns filter and trigger, pairs for confluence, writes falsifiable why. Long/short mirror and exits handled — short auto-mirrored, full exit stack (stop, target, trailing, break-even, time) pre-wired.
Shapes it can design
• Stop entry — filter + trigger at a price level
• Market entry — filter + trigger, immediate fill
• Session-gated — market entry + non-directional time gate
• Multi-timeframe — daily regime filter + main-chart trigger
• Role-structured with veto — regime AND trigger AND NOT veto
• Multi-leg — several independent entry legs with own order type and exit timing
• Long-only variants of the above
How to use it
Step 0 — One-time setup
Point the skill at your StrategyQuant X install top-level folder (e.g., D:\SQX_144_…). It scans and lists clean random groups you can wire, excluding any that reference missing blocks.
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."
Step 2 — Review and approve
Skill replies with plain-English design spec (template name, shape, filter, trigger, thesis, short-side handling). Approve or request changes.
Step 3 — Generate and validate
Skill wires groups into skeleton, mirrors short side, self-validates. Won't return result unless every group resolves and hole is filled.
Step 4 — Import and Build
Import the .sqx file and run a Build in AlgoWizard. Builder searches within template structure using your groups.
Step 5 — Iterate if needed
If template doesn't build, tell the skill — it fixes the specific shape rather than rewriting. Most common cause: group referencing unimported block; import block, regenerate.
Part of a bigger toolkit
• Custom Block Builder — author signals and price levels
• Random Group Builder — pool blocks into builder menus
• Strategy Template Builder — wire groups into .sqx templates (this skill)
Requirements
• StrategyQuant X / AlgoWizard — build 144 or later
• Python 3.8+ (standard library only, no pip installs)
• Claude Code with skill installed
• Random groups in your install (build with Random Group Builder if needed)
At a glance
Input: Strategy idea in plain English | Output: Validated, import-ready .sqx template (long + short) | Builds from: Your install's clean random groups | Structure: Build-confirmed skeletons; full exit stack wired; short mirrored
FAQ
What's a strategy template versus a strategy? A template is a strategy with holes the builder fills as it searches, pointing at your random groups.
Will this work on my SQX version? Targets StrategyQuant X build 144; reads your install and wires only groups you have.
Does it invent strategies? No — only wires random groups already in your install. Build missing pools with Random Group Builder first.
Why transplant instead of write XML? SQX templates can be type-correct yet fail to build; transplanting into proven skeletons keeps every template inside valid territory by construction.
Does it handle long/short and exits? Yes. Short mirrors long automatically; full exit stack (stop, target, trailing, break-even, time) pre-wired.
Multi-timeframe and session filters? Yes — both supported shapes.
Do I still build in AlgoWizard? Yes — design template with skill, import and Build in AlgoWizard as usual.
You know me as clonex. I'm Ivan Hudec — I built the free blocks here and write research at algotrading.space. Work with me.
