Business logic should be effortless.
Define your business rules once in a living rulebook. Your database, API, docs, and validations are all derived from it, proven to stay in sync as your business evolves.
The Problem
Every software project
hits the same wall.
Business rules get encoded once, and then again, and again. Into the database, the API, the frontend, the docs. Each copy drifts. A rule changes and you spend a week hunting every place it lives. This is not a tooling problem. It is an architecture problem. There is no single place that owns the logic.
Logic scattered across the stack
Business rules end up encoded separately in the database, the API, the frontend, and the validation layer. Each location becomes its own source of truth. There is no single place to change a rule.
Changes cost more every time
When a rule changes, you have to find every place it lives, understand the blast radius, and update them all consistently. Miss one and you have a silent bug. The cost per change grows with the codebase.
The model stops being the system
Without a living model, the system is what the code says it is. Each layer has its own version of the rules, written at different times, by different people. To understand the system, you excavate. Code is archaeology.
The Solution
Model it once.
Derive it everywhere.
Business logic belongs in a model, not in code. The rulebook is that model: one typed grid of entities, fields, formulas, and relationships. Every table, field, relationship, formula, and permission is declared once. A pipeline of versioned transpilers reads that declaration and derives everything else. When a rule changes, you change the model. The pipeline reruns. Everything updates. Completely, consistently, everywhere.
See it happen: one rule, seven files, one build →One typed grid of entities, fields, formulas, and relationships, authored in plain language through Effortless skills. This is your Single Source of Truth.
Derives the full SQL layer: normalized tables, calculated field functions, vw_* views, row-level security policies, and seed data inserts.
pg-rulebook →
Derives the app, including the provenance panel: any value on screen can show exactly how it was computed, all the way down to ground truth.
RuleSpeak® prose. Every rule restated as a plain-English sentence, regenerated on every build. Always current. Never stale.
vw_* Views
One row = everything your application needs. The view assembles it. Your application code never joins.
calc_* Functions
A DAG of single-responsibility functions. Calculated fields compose correctly. No circular dependencies possible.
Base Tables
Normalized facts only. Your application writes here and reads from views. Clean separation of concerns.
Watch
Where decisions usually go.
A short walkthrough of what happens to business logic today, and what changes when it lives in a rulebook instead.
Getting Started
Start building today.
Free to use.
The Effortless skills and CLI are open source. Build, prototype and ship without paying us anything. Commercial licenses are for companies running many projects at once, and for large organizations.
- 01
Add Effortless to Claude Code
Two commands install the Effortless skills.
- 02
Describe your app in one sentence
Claude writes the rules and builds a working app.
- 03
Change a rule
Say it in plain language. The whole app follows.
Training
Go faster with a training session.
The fee converts to credit.
Getting started on your own is free. Training is the fastest way to get it right: we walk your team through the methodology, hands-on with real tooling. Pick the depth that fits where you are.
Free
1 hour onboarding
Not sure yet? Spend an hour with us. We'll look at your project, tell you honestly whether Effortless is a fit, and help you get going.
2 hours
Introduction
Hands-on walkthrough of the methodology and toolchain on a real project. By the end, you know exactly how to apply it on your next engagement.
Fully converted into store creditSee details →2 sessions
Hands-On Workshop
Build a real system slice from scratch - schema design, modeling surface setup, first effortless build, consuming views in app code.
$1,000 converts to store creditSee details →5 sessions
Team Onboarding
A complete adoption engagement for your team. Covers the full Bootstrap + Effortless Loop cycle and ends with a working, production-ready system slice your team owns.
$2,500 converts to store creditSee details →Larger scope · Custom package
Deep Enablement
For bigger teams and multiple projects: the full , edge cases, schema evolution, and organization-wide adoption. Scoped up front as a fixed package with a clear finish line.
Online sessions for individuals and small teams. For onsite workshops, firm-wide enablement, or larger engagements, get in touch and we'll work out the right arrangement.
The Divergence
Same speed on day one.
A very different month six.
Both approaches start fast. The difference shows up under change, when requirements evolve and you have to track down every place a rule lives.
- ✕Business rules encoded in DB, API, frontend, and validators simultaneously
- ✕Cost per change grows with codebase size
- ✕Consistency requires discipline. Discipline fails.
- ✕The model and the system diverge. Only the code is authoritative.
- ✕Non-developers cannot read or audit the system
- ✕Pipeline improvements don't propagate to your project
- ✓Business rules live in one place, readable by anyone
- ✓Cost per change stays flat. The pipeline is stateless and doesn't care how big the system is.
- ✓Consistency guaranteed by derivation, not by discipline
- ✓The rulebook remains authoritative at month six and beyond
- ✓Product managers can read, audit, and change rules without engineering support
- ✓Pipeline improvements across all customers flow into your project on next build
A natural side effect
Invisible rules break.
Explicit rules don't.
When AI coding agents build on top of a grounded rulebook, they build correctly. The rules aren't invisible in prompts. They're explicit in the model. The agent only needs to build the interface.
Built For
See it in your context.
AI Teams
Ground your agents in a rulebook, not a prompt.
AI coding agents build correctly when the rules are explicit in the model. See how the model-first approach applies to teams building with AI.
Learn more
Professional Services
We build your project model-first.
Hire us to capture your rules, derive the foundation, and build the interface in fast iterations. You keep the rulebook when the engagement ends.
Learn more
Dev Shops
Bring a methodology to every engagement.
Adopt the model-first approach and the toolchain in your own shop. Deliver better software on every project and give clients something they can own.
Learn more
Business Consultants
Turn your analysis into a living model.
Model client domains in a form that drives real systems. Deliver a structured rulebook that outlasts the engagement - and positions you as the bridge between business intent and working software.
Learn more
Ecosystem
Pick your stack. We derive the rest.
Author the rulebook in plain language, or import an existing system. Postgres, React, RuleSpeak®, Explainer DAG, Python, Go, C#, REST, GraphQL, Excel, OWL and more, all generated from the same rulebook. See all supported sources and outputs.
Explore the ecosystem →
The source of truth belongs
in the model, not the code.
Book a free 30-minute demo. We'll build a functional prototype from your rules and run the full pipeline while you watch.