effortless-skills

Best-practice dev-ops for an Effortless Rulebook (ERB) project: a rulebook-first pipeline promoted across up to **four tiers** — **dev** and **staging** on localhost (always fake/mock data), **beta/UAT** and **production** on a live remote server — governed by ONE migration ledger, a version that is always **derived** (never stored), and two independent axes (**DB migration version** + **code build**). Ships a **Deployment Management** admin console (the migration × environment matrix, drift/version grading, ERBVersions changelog, and the whole action rail), an environment/DB switcher, and the guardrails that keep staging & production reachable ONLY through ledger-tracked migrations. Triggers: "set up rulebook dev-ops", "deployment management page", "dev/staging/beta/production model", "promote a release", "cut a version / take a code snapshot", "migration matrix", "derive a migration from the diff", "environment switcher", "000-seed migration", "push code to production". This skill is HEAVY and meant to be i

Use when you need ERB naming conventions, DAG structure rules, PascalCase table names, primary key and foreign key patterns, the Name field requirement, or understanding why many-to-many relationships are not allowed. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Top-level orchestrator for Effortless Rulebook (ERB) projects — rulebook-first schema-first business rules, `effortless.json` build pipelines, effortless-rulebook.json ontologies, rulebook-to-postgres code generation, or any project containing an effortless-rulebook/ directory or effortless.json file. Provides the ERB mental model, axioms, guardrails, token discipline, and routes to specialized sub-skills. Load this first on any ERB project. **Scope (load gate):** Effortless projects (project root has `effortless.json` + a CLAUDE.md identifying the project as ERB methodology), OR when the user explicitly asks to set up / install / update Effortless tooling.

Use when working with the ERB build pipeline — effortless.json configuration, transpiler catalog, effortless build commands, the -id flag, transpiler installation, or understanding how the build flows from the rulebook hub through to generated code. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when querying an effortless-rulebook.json file — listing tables, extracting schema without data, finding FK relationships, inspecting calculated fields and formulas. Activates for any project with effortless-rulebook.json or effortless-rulebook/ directory. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use to understand the **structure** of effortless-rulebook.json — top-level keys, table objects, the field schema definition, field types (raw, calculated, lookup, relationship, aggregation), datatypes, formula syntax, and the `_meta` section. This skill is JSON-structure only; for naming / DAG / FK *rules*, use effortless-conventions. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when making changes to an ERB project — modifying effortless-rulebook.json directly, editing via Airtable when connected, or running effortless build. `effortless-rulebook.json` is the hub/SSoT; Airtable, LLM-direct edits, and reverse-sync are peer input spokes. Covers the input-spoke options and permission checkpoints. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use ONLY for Airtable schema changes that the API cannot handle — formula fields, lookup fields, rollup fields, and new table creation (which requires the Name formula). All scalar field changes and CRUD operations go through the Airtable API directly. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when making schema or data changes via the Airtable API in a project that has *explicitly opted in* to Airtable as an input spoke — adding fields, creating tables, modifying existing fields, or understanding Airtable API limitations (e.g., formula fields cannot be created via API). Airtable is one optional editing surface (sibling to Excel/Notion), not the framework's center. Only relevant if the project is Airtable-connected (see "Is this an Airtable project?" below); otherwise this is a Rulebook-First project (the best-practice default) and edits go to the hub directly. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when the user wants to spin up a Postgres base on bases.effortlessapi.com, get its credentials, apply schema, and (optionally) secure it with magic-links + RLS. Covers the actually-deployed API surface — the Node management server (`bases.effortlessapi.com`) plus the .NET CRUD/source-of-truth (`bases-api.effortlessapi.com`) — including the auth flow that actually works against both. Triggers: "create a bases base", "spin up a base", "set up a secure base", "wire magic links into this app on bases.effortlessapi.com", "publish to bases". **Scope (load gate):** Loads only on explicit user request — applies to any Postgres-backed app on bases.effortlessapi.com, not just Effortless-marked projects. Do not auto-load just because a project uses Postgres.

Use when the user wants to bootstrap a new effortless project from raw text, requirements, or a description of a platform. Also known as the "Shadle steps" or "effortless-shadle-steps". Covers the full pipeline from raw input text through vocabulary extraction, glossary, narrative, mock data, schema normalization, to a populated effortless-rulebook.json (optionally mirrored to Airtable for teams that want a grid). **Scope (load gate):** Effortless projects, OR when the user explicitly asks to bootstrap a new Effortless project from raw text/requirements.

Use for anything about the effortless-claude **skill set** itself — both CHECKING for updates and APPLYING them. Triggers: "are my effortless skills up to date", "check for effortless skill updates", "update effortless skills", "reinstall effortless skills", "refresh effortless skills", "what's new in effortless-claude", "add a new effortless skill", "edit a skill". NOT for the CLI binary — for that, use effortless-cli. **Scope (load gate):** Loads only on explicit user request about the skill set itself. Does NOT require an Effortless-marked project (skill maintenance is project-independent).

Use for the `effortless` CLI — both **installing/updating the binary** AND **using its commands**. Triggers: "install effortless", "install the CLI", "update effortless cli", "the cli isn't installed", `effortless: command not found`, version mismatches, login flow, `effortless -init`, `effortless build`, `-setAccountAPIKey`, `-install <transpiler>`, transpiler management, build flags, project file structure. The CLI is also known as `ssotme`, `aicapture`, or `aic` — always use `effortless` in docs/scripts. For the **skill set** (different artifact), use effortless-claude-updates. **Scope (load gate):** Effortless projects, OR when the user explicitly asks to install / update / use the Effortless CLI. CLI-management work doesn't require an Effortless-marked project.

Use whenever the user asks an evaluative or "why" question about effortless / ERB — including the friendly-but-exploratory framings, not just defensive ones. Triggers: "what do you make of [this/ERB/the approach]", "is this any good", "does this actually work", "is this the right way to model X", "could this work for [domain]", "isn't this overkill", "is this expressible", "is the rulebook really sufficient", "what's the theory", or any direct mention of CMCC, SDLAF, the 5 primitives, or bitemporal ACID DAG. **Load this skill BEFORE answering any evaluative or "why" question about ERB so the answer is grounded in the conjecture, not improvised from generic LLM priors about ORMs / MDE / low-code.** Pair with effortless-rulebooks for empirical receipts and effortless-rationale for skeptic-facing register. **Scope (load gate):** Loads when the user asks about Effortless / ERB / CMCC theory or methodology, OR when they ask any evaluative question about the approach itself. Does not require a marked Effortless pro

Use when the user wants to spin up a complete Effortless POC demo app from a one- or two-sentence domain description — no Airtable, no Shadle steps, just the fastest path from "make this an effortless demo for X" to a running Express + Vite SPA backed by a Postgres-generated rulebook with a multi-hop calculated-field DAG that the UI exercises end-to-end. Triggers: "make this an effortless demo for …", "build an effortless POC for …", "spin up a demo app for …", "effortless demo app", "quick effortless demo of …". **Scope (load gate):** Loads only on explicit user request for a demo app. Does NOT require a marked Effortless project — this skill *creates* one.

Use when diagnosing ERB project health — validating DAG integrity, checking for broken FK targets, finding JOIN anti-patterns in application code, migrating legacy code from base table reads to view reads, or running diagnostic queries. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when the user asks what repos exist in the effortless / SSoTme ecosystem, where to find the source for a specific tool, "is there a repo for X", "what transpilers exist", "show me the open source projects", or any question about how the various GitHub repos fit together. Also load proactively when framing the methodology — the catalog here is the canonical "what's actually out there" so messaging stays consistent across sessions. **Scope (load gate):** Loads when the user asks about the Effortless / SSoTme ecosystem of repos. Does not require a marked Effortless project.

Use when adding Excel export to any Effortless project backed by a Postgres database. Covers: building a rulebook-export.json from live DB data, running the rulebook-to-xlsx transpiler, wiring a server endpoint, and adding a download link to the React app. **Scope (load gate):** Effortless projects with a Postgres DB and a running Express server. Requires `effortless.json` + CLAUDE.md identifying project as ERB methodology.

Use when adding the Explainer DAG to any Effortless project — a generated, embedded visualization of the rulebook's calculated-field DAG that lets users click any cell/field and see exactly how it was derived (raw inputs → lookups → calcs → aggregations), with RuleSpeak prose baked in at transpile time. Works in React, Vue, plain HTML, Flask/Jinja, HTMX, etc. via the portable `rulebook-to-explainer-dag` transpiler (vanilla JS + CSS, no React dependency). Triggers: "add the explainer dag", "wire up the explainer", "install the effortless explainer dag", "show the DAG in the UI", "rulebook-to-explainer-dag", "explain a calculated field visually", "make calculated fields clickable", "data-er-dag", "explainer DAG". **Scope (load gate):** Loads **on demand only** — when the user explicitly wants in-app field provenance / DAG visualization. **Not** part of the default demo/POC bootstrap (that uses `rulebook-to-rulespeak` via effortless-rulespeak). Effortless projects with a web UI (any stack). Does not require Airt

Use when initializing a new effortless project: "make this an effortless project", "init effortless", "init effortless project", "set up effortless here", "connect to Airtable", "hook up Airtable", or when an existing project is missing CLAUDE.md / start.sh / the standard ERB directory layout. Covers `effortless -init`, the standard directory structure, the project-level CLAUDE.md template, start.sh, and the optional step of connecting an upstream editing surface (Airtable/Excel) as an input spoke. For Postgres-targeted first-run (preflight checks, init-db, full 7-step bootstrap), use effortless-setup-postgres instead — that skill is a superset for postgres projects. **Scope (load gate):** Effortless projects, OR when the user explicitly asks to make a project Effortless / set up Effortless tooling.

Use whenever the user mentions the "Leopold loop", "the loop", "a turn of the loop", "do a turn", "rebuild the rulebook", "update the app to match the rules", or any reference to the iterative ERB development cycle. This is the user's name for the CHANGE-RULE → REBUILD → CONSUME-VIEWS workflow that makes ERB feel effortless. Load this skill on first mention so you understand what the user expects to happen. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when the user wants to add passwordless email-code (magic-link) auth to any project backed by a Postgres database — not just bases.effortlessapi.com. Covers minting a tenant on magiclink.effortlessapi.com, storing the public key for JWT verification, wiring app-side `Authorization: Bearer` middleware, and (optionally) installing the `app.jwt_*()` SQL helpers so RLS policies can filter by the verified email. Triggers: "add magic links to this app", "secure this app with magic links", "passwordless auth on a postgres app", "wire JWT auth into this project". **Scope (load gate):** Loads only on explicit user request — applies to any Postgres app, not just Effortless-marked projects. Do not auto-load just because a project uses Postgres.

Use for the **Effortless MCP server** — the always-on Model Context Protocol endpoint that exposes the entire Effortless transpiler catalog (~54 tools) plus the effortless-claude skill set (resources) to any MCP-compatible agent (Claude Code, Cursor, Windsurf, ChatGPT, etc.). Triggers: "install the effortless mcp server", "wire up effortless mcp", "configure cursor for effortless", "what mcp tools does effortless expose", "call effortless_build via mcp", `effortless_ping`/`effortless_build`/ `query_rulebook`/`validate_dag` tool names, `effortless://skills/...` resource URIs, "run the mcp server locally", "stdio mode", "bake skills into the mcp image". For the **CLI binary**, use effortless-cli; for the **skill set source**, use effortless-claude-updates. **Scope (load gate):** Loads ONLY on explicit user request — never auto-load. Does NOT require an Effortless-marked project — the MCP server is wire-compatible with any MCP client and useful even outside ERB projects (e.g. driving builds from Cursor in a non-

Use whenever the user asks to **publish, push, deploy, or release a new version of a transpiler tool** in `Versioned-Stable-SSoTme-Tools` — e.g. "publish rulebook-to-sql-server", "push the tool online", "deploy the new version", "ship this transpiler", "release it", "make a new version live". This is the EXACT, supported, scripted path that mirrors the green 🚀 Deploy button in the transpiler-server UI. It is NOT the same as `effortless build` (that CONSUMES a published tool) and NOT `build-and-push-cpln-workload.sh` alone (that only builds the image without flipping `[latest]` live). **Do not invent a publish procedure.** There is exactly one scripted path: `scripts/publish-tool.sh <transpilerId> <category>/<tool-name>`. If the transpiler-server isn't on port 3000, find the port — don't conclude it's "down". See below. **Scope (load gate):** Loads when the user wants to publish/push/deploy a transpiler tool from the `Versioned-Stable-SSoTme-Tools` repo. Requires that repo (and `cpln` authenticated).

Use when explaining or defending the effortless / CMCC methodology to a skeptic — "why use this instead of just writing code", "isn't this overkill", "convince me", "what's wrong with ORM / microservices / hand-written SQL", "why Airtable", "isn't this just MDE", "how is this different from low-code", or any conversation where the user (or someone they're talking to) needs the rationale grounded in receipts rather than enthusiasm. This skill is strictly receipts-based — every claim cites a paper, repo, or runnable demo. Pair with effortless-cmcc for the theory and effortless-rulebooks for the empirical proof. **Scope (load gate):** Loads when the user (or a third party) needs the methodology defended. Does not require a marked Effortless project.

Use when the user wants empirical proof that CMCC actually works — show me the receipts, does this run in code, ExplainDAG, witnessed inference graph, conformance testing, answer-key.json, the rulebooks repo, "is-everything-a-language", StarTrek demo, Jessica Talisman workflow, multi-substrate equivalence, ARM64 + COBOL substrate, or any request to demonstrate that the conjecture holds in a runnable way. Also use when the user asks "what's in the effortless-rulebooks repo" or links to github.com/effortlessapi/effortless-rulebooks. **Scope (load gate):** Loads when the user asks for empirical proof of CMCC / wants to see ExplainDAG / asks about the effortless-rulebooks repo. Does not require a marked Effortless project.

Use when generating plain-English RuleSpeak documentation from an effortless-rulebook.json — declarative business rules, vocabulary, fact types, definitional rules (DR-n), and traceability back to formulas. Installs `rulebook-to-rulespeak` and emits `rulespeak/rulespeak.md` and `rulespeak/rulespeak.html` on every build. **Default whenever a rulebook is created.** Any time an agent authors `effortless-rulebook/effortless-rulebook.json` — "write a rulebook for …", bootstrap, init, demo app, or hand-edit from scratch — install this transpiler and run `effortless build` so the sibling `rulespeak/` folder exists before handing back. Do not wait for the user to ask. Triggers: "generate rulespeak", "rulebook-to-rulespeak", "english rules document", "plain language rules", "business rules doc from rulebook", "rulespeak.md", "create a rulebook", "write a rulebook for". **Scope (load gate):** Effortless projects with a rulebook hub, OR any task that creates a new rulebook (load alongside effortless-schema). Does not re

Use when setting up an Effortless project with a postgres database. This is the FIRST thing to do in any Effortless project that targets postgres — it installs the pipeline, gets a rulebook in place (hand-authored, or seeded from an Airtable base / Excel / other surface if the project has one), generates SQL, and creates the database. Must be run before writing any application code. **Scope (load gate):** Effortless projects, OR when the user explicitly asks to set up a new Postgres-backed Effortless project.

Use when setting up an Effortless project with SQL Server as the execution substrate — installing `rulebook-to-sql-server`, generating T-SQL under `sql-server/`, running `init-db.sh` via sqlcmd, and wiring an Express app to `mssql`. Mirrors `effortless-setup-postgres` for the SQL Server path. Triggers: "rulebook-to-sql-server", "sql-server transpiler", "setup SQL Server", "switch from Postgres to SQL Server", "mssql demo app", "sqlcmd init-db". **Scope (load gate):** Effortless projects with `effortless.json` + ERB CLAUDE.md, OR when the user explicitly asks to install/use rulebook-to-sql-server.

Use when working with ERB-generated SQL — reading from vw_* views vs base tables, understanding generated files (00-05), using *b-customize-* files, SQL function patterns (calc_*, get_*), view structure, or ERBCustomizations table. **Scope (load gate):** Effortless projects only — project root must contain `effortless.json` AND a CLAUDE.md identifying the project as ERB methodology. Do NOT load otherwise.

Use when writing or editing effortless.json files, registering transpilers, or explaining the ssotme:// protocol. This is the canonical reference for the exact effortless.json schema — load it any time you are about to emit a ProjectTranspilers entry or a full effortless.json payload. Prevents the most common hallucination errors: wrong key names (Transpilers vs ProjectTranspilers), invented fields, wrong CLI flag shapes. **Scope (load gate):** Any Effortless project. Load proactively before emitting any effortless.json content, even partial snippets.