Why Our Engines Are Strong — and Where We Are NOT the Best Yet (honestly, no invented numbers)
In short
An honest map with no invented numbers: no "100x" claims — we have no such measurements and we're not going to make them up. There is one main strength, and it's verifiable in the code: what we sell is not a prompt pack but a typed, composable SPEC that a deterministic compiler assembles into native packages for three targets from a single source. On top of that: review discipline out of the box (13 prisms, five veto prisms with weight 2, a tie counted as BLOCK, an iteration cap), a portable ENFORCED safety net via a git hook and CI, granular rule activation, and honest labelling of ENFORCED versus ADVISORY. Where we're not the best yet is listed in its own section, just as bluntly.
What it is
This article is not marketing. It's an honest map of where we're objectively strong and where we aren't yet. No "100x", no "15% fewer bugs" — we have no such measurements and we're not going to invent them.
Where we're genuinely strong (one confident headline claim)
We don't sell a prompt pack — we sell a typed, composable SPEC that a deterministic compiler assembles into native packages for three targets from ONE source. This is verifiable in the code: engine-mod/v1 is a zod-validated artifact (schema.ts); the exportMod() dispatcher routes a single spec into Claude Code (.claude-plugin + agents + commands + hooks), Cursor (.cursor/rules/*.mdc) and a universal AGENTS.md, and throws on an unknown target. The market mostly ships prompt libraries and one-off presets; a validated, multi-target-compilable engine format with a marketplace on top is something almost nobody has.
What else is strong and actually built (not promises):
- Review discipline out of the box: 13 prisms, 5 of them vetoes with weight 2, a deterministic synthesis rule (a tie → BLOCK),
verifyVotes: 2,loopUntilDrycapped at 2 rounds of "fix the class → re-judge", plus adaptive tiering by diff size (LIGHT/STANDARD/HEAVY — we don't burn quota on trivia). That is noticeably more than "you are a helpful reviewer". - A portable ENFORCED safety net on every target (
safetyFloor.ts): git pre-commit + CI, the same scan for secrets and destructive commands, failing with a non-zero exit code — not with prose. - Granular cross-target rule activation:
always / auto(globs) / agent(description) / manual, compiled into each target's native mechanism from one spec. - Honest ENFORCED vs ADVISORY labelling and a floor for weak models: behavior is a literal recipe, so even a weak target model can execute it.
Where we are honestly NOT the best yet
1. Determinism is a property, but it has no test of its own yet. The compiler is designed to be byte-identical (safetyFloor says "no timestamps, no randomness"), BUT exporters.test.ts checks content presence, routing and secret redaction — not idempotency. Until there is a test that says "export twice → deep-equal the file maps", we claim the FORMAT and multi-target compilation as the differentiator, and byte-identity only as a design intent. The determinism test is roadmap.
2. Veto prisms are a strong DEFAULT, but not a moat. Five veto angles with fixed synthesis are valuable, but the prism rubric ships in the package as plaintext and can be copied. We accept that as the price of autonomy: the package is fully readable, and the buyer sees everything they paid for.
3. Full autonomy — on purpose. The package is entirely self-contained: the workflow, prism rubrics and memory (the decision log and notes in .engine/) live with you, offline, with no dependency on our servers. That's a deliberate choice in favor of ownership: what you bought stays yours even without our servers. Artifact identity is confirmed by .engine.json with its contentHash and by the portable safety floor.
4. Runtime quality depends on the target model. We reduce that dependency with literal recipes and a floor for weak models, but we don't run the model — which means we can't guarantee the quality of the OUTCOME the way a product that hosts execution can. This is quality of INSTRUCTION, not control over execution.
5. Cross-target rule activation vs free Cursor. Cursor Project Rules (always / auto-glob / agent-requested / manual) are a free built-in feature that matches our model ON the Cursor target. Our real, narrow edge is compiling one activation model into THREE targets from a single spec, plus self-specializing the globs to your stack at install time — not "we beat Cursor on its own turf".
6. The intent router is ADVISORY self-selection. The exporter ships all agents unconditionally; forge.route doesn't exist. "We keep the base light with routing" means the target model picks for itself based on text, not enforced routing. A real router is roadmap.
7. AI assembly from a free-form goal ("describe the goal → get an engine") is ROADMAP, in development. Today you ASSEMBLE or PICK an engine; generation from a free-form goal isn't ready.
8. Coverage is narrow on purpose and WITHOUT data. Quest covers building software (feature/API/UI/fix/refactor/release), but it does NOT cover data analysis/ETL/reporting, and it doesn't cover video/decks/growth/design craft — those are separate packages (roadmap). "It does everything" is only true for the domain of software creation minus data.
Example: input → what the engine does → result
Input. An agency wants a single engine team with veto review for security and tenancy, deployed in Claude Code, in Cursor, and in a client's repository on VS Code/AGENTS.
What the engine does. One engine-mod/v1 spec is compiled by exportMod() into three packages: Claude gets a plugin plus a guard hook (ENFORCED), Cursor gets .mdc rules, and all three get the portable pre-commit and CI floor (an ENFORCED secrets scan). The security and tenancy prisms ride along with veto power in all three; the synthesis rule "a tie → BLOCK" is identical everywhere.
Result. From ONE source, three native, consistent packages with identical discipline and honest labelling of guarantee levels. Each already carries .engine.json with its contentHash and the portable safety floor (pre-commit + CI). What they will NOT get today: byte-identity proven by a test; from-goal generation; coverage for data or video. That's roadmap, and we call it roadmap.
Bottom line
There is exactly one headline strength: a validated, composable spec compiled into three native targets, with a marketplace on top (determinism pending its test). The review model (veto prisms + synthesis) is a strong preconfigured default, but a copyable one. The package is self-contained by design: memory lives locally in .engine/, the version you bought is yours forever, and a new core version ships as a separate product. .engine.json with its contentHash and the portable safety floor are already emitted. We're strong where we're strong, and we say plainly where we aren't yet.