Most rule engine vendors assume that if they show a screenshot of their rule editor, visitors will immediately understand its value. In reality, executives and architects are rarely concerned with particular design features of the editor. What they really want to know is:
- Is this just another programming language in disguise?
- Will business users need weeks of training?
- Will we create a governance nightmare?
- Can the editor adapt to our domain?
- Will users be overwhelmed by hundreds of irrelevant fields?
- How do you keep rule authoring simple when decisions become complex?
- If AI writes a rule, can we still read it, trust its structure and control whether it goes live?
What Makes the Code Effects Rule Editor Fundamentally Different?
Every business rules engine allows someone to define rules. The real question is: Who can realistically create and maintain them?
For decades, most rule authoring tools have forced organizations into an uncomfortable compromise.
Either: Give business users powerful tools that require learning specialized syntax, scripting languages, or technical concepts.
Or: Restrict rule creation to developers and accept that every policy change becomes a software project.
Code Effects was designed to eliminate that compromise. The same Rule Editor serves business users who have never written a line of code and developers who want a precise, typed rule language bound to their own .NET classes. In Code Effects 7, it is also the place where people read, check and adjust the rules that AI writes.
We are so confident in the simplicity and effectiveness of the Code Effects Rule Editor that we invite anyone to experience it firsthand. Unlike vendors that rely solely on screenshots, videos, or guided demonstrations, we provide a publicly accessible live demo where you can build rules yourself against a real test source object. We believe the best way to understand the value of our menu-driven approach is not to read about it, but to use it. A few minutes with the editor often demonstrates more clearly than pages of documentation how sophisticated decision logic can be authored without programming knowledge.
Rules Built Through Conversation, Not Programming
Instead of asking users to write expressions, formulas, or scripts, the Code Effects Rule Editor guides them through rule construction one decision at a time. Users select from menus. The editor assembles complete business statements automatically.
A rule might read:

No syntax. No keywords to memorize. No programming knowledge required. Notice how you were able to read this Code Effects rule created using our live demo and immediately understand the business logic it defines without deciphering or translating any cryptic format. Compare that experience with interpreting a typical decision table, where the logic is often hidden behind rows, columns, abbreviations, and conventions that require detailed explanation before they can be understood by non-technical users.
In Code Effects platform, users focus on expressing business intent rather than learning how to communicate with software.
The same readability applies to rules written by AI. Whether a rule was built through the menus, written by the AI Rule Editor from instructions in any language, or saved by an AI agent through the MCP server, it is displayed in its entirety in the same readable form - without fragments, special representations or diagrams to assemble.
Web-Based by Design
The way people work has changed.
Decision-making no longer happens at a single desk, on a single machine, inside a single office. Teams are distributed across locations, departments, platforms, and devices. Business applications are delivered through browsers, administrative portals, and cloud-based environments.
The Code Effects Rule Editor was designed with this reality in mind.
Because it is a web-based component, the editor can be embedded directly into the applications your users already access every day. There is no separate desktop application to install, distribute, update, or support. Users simply sign in to your application and begin authoring rules through the same interface they already know.
This approach provides several important advantages:
- Zero desktop deployments. New versions of the editor become available immediately through your existing web application deployment process.
- A consistent experience. Every user works with the same version of the editor, eliminating compatibility issues and version mismatches.
- Remote accessibility. Authorized users can create and maintain rules from anywhere they can securely access your application.
- Simplified administration. IT teams manage one application instead of maintaining separate desktop installations across the organization.
- Seamless integration. The editor naturally becomes part of your existing portals, dashboards, and administrative workflows. It runs in any .NET web application - ASP.NET Core, MVC, Razor Pages, Blazor or WebForms - and works with React, Angular and Vue as well as plain pages, delivered as the dependency-free @codeeffects/editor npm package.
- Cross-platform access. Users can work from Windows, macOS, iOS, Android, Linux, and other environments through modern browsers without additional client software, with layouts that adjust to tablets and phones.
- Faster adoption. Because the editor appears within familiar business applications, users often perceive it as a natural extension of the systems they already use rather than a new tool they must learn.
- Public-facing use. The same editor can be placed in a customer-facing page, so that untrained visitors can build their own rules or data filters without learning how rules are built in your project.
For organizations that have experienced the complexity of traditional desktop-based rule authoring environments, the difference is substantial. Rule management becomes another capability of the application itself - not another system to deploy, secure, train, and support. The Rule Repository, new in Code Effects 7, follows the same model: a complete rule management application with the Rule Editor built in, placed in one element of your own page.
In practice, this means business users spend less time learning tools and IT teams spend much less time maintaining them.
The result is a simpler path from policy creation to decision automation.
A Refreshed Interface That Looks Like Your Application
Version 7 brings a refreshed look to the editor: redesigned date and time pickers, light and dark themes, fonts inherited from your page and text sized in percentages, so the editor aligns with your application's visual design. Its common, light and dark stylesheets can be changed like any other CSS in your project. Names, descriptions and values are always displayed as text, and the editor builds its interface without HTML strings, so it works on pages that enforce Trusted Types without additional setup.
Traditional rule systems often allow users to create invalid expressions and discover mistakes later. Code Effects takes a different approach.
At every step, the editor only presents options that make sense. If a field contains dates, users see date operations. If a field contains numbers, they see numerical comparisons. If a field is of ICollection type, only operations appropriate for collections become available. If a field holds a duration, users see operators such as is longer than and is shorter than, and a duration picker in the units configured for the field, so a length of time is never confused with a time of day. Dates, times and offsets are entered through pickers that never accept an invalid value, and the editor prevents optional values from being passed to operations that cannot accept them.
The editor actively guides users toward valid rules while preventing impossible combinations. Validation happens naturally during authoring rather than after the fact. Every saved rule is structurally valid against its source object, whoever or whatever wrote it: the server checks it again before the rule's XML is produced, including checks for circular references between rules, so no human structural review is needed. Whether a rule expresses the intended policy remains a matter for tests and approvals.
Complex Logic Without Complexity
Business decisions are rarely simple. Policies often contain exceptions, alternatives, and nested conditions. The challenge is exposing this complexity without overwhelming users. Code Effects allows authors to create sophisticated rules using familiar constructs such as:
- AND and OR logic,
- grouped conditions,
- nested expressions,
- method calls,
- numeric calculations,
- reusable logic,
- collection operations,
- execution paths with side effects.
Version 7 expands that language for people and AI alike:
- membership conditions such as Status is in (Active, Pending), and their opposite is not in,
- inclusive ranges with is between, and their exact opposite is not between,
- one Collections... menu with exists, does not exist, all, first, last, count and count with,
- strings composed with Concatenate...,
- date shifts such as Order Date + 30 days,
- date-only and time-only values, and dates and times with an offset,
- durations with operators of their own,
- inline rules that let an execution rule run another execution rule from its THEN or ELSE section.
Yet each step remains menu-driven. Users work through decisions incrementally instead of confronting an intimidating programming environment, and more complex decisions can be expressed as single, complete, readable rules.
A User Experience That Feels Familiar
The Rule Editor behaves much like the applications people already use every day. Users point, click, select, and edit. They can:
- use the keyboard or mouse,
- copy and paste rule segments,
- rearrange conditions,
- group related statements,
- edit individual expressions,
- review rules in human-readable form.
Organizations typically introduce the editor as another screen inside an existing administrative portal. For many business users, little formal training is required.
Built for Your Business Language
No two organizations describe their world in exactly the same way. Code Effects allows the Rule Editor to reflect your terminology rather than ours. Field names, method names, labels, descriptions, help messages, and text presented throughout the interface can be customized to match your domain, and HelpXML translates the entire editor - operators, clauses, buttons and messages - into any language or terminology, per user if needed. The Rule Repository takes all of its own text from a single translatable XML file the same way.
Users see concepts they already understand. Not technical abstractions. Not vendor-specific terminology. Your business speaks its own language. The editor simply reflects it.
In Code Effects 7, source members can also carry aliases and descriptions meant for AI, so AI agents understand your business terms without changing the labels users see.
Traditional rule editors present every available field and method from the beginning. As systems grow, that approach quickly becomes overwhelming.
Adaptive Source changes that experience completely.
Instead of exposing everything at once, the editor can determine what should appear based on the rule being authored at that exact moment. As users build a rule:
- previously selected conditions can influence future menus,
- earlier decisions can narrow available choices,
- irrelevant options can disappear,
- context-specific guidance can emerge.
The result feels less like browsing a data model and more like having a conversation with an expert assistant. The editor continuously adapts to the author's intent.
In version 7, Adaptive Sources work in the Rule Repository as well as in stand-alone implementations, next to .NET classes and Source XML.
Context Resetting: The Freedom to Change Direction
One of the challenges of context-aware authoring is knowing what happens when users change their minds. Adaptive Source addresses this through Context Resetting.
If users modify or remove earlier conditions that previously influenced the editor's context, the editor automatically recalculates what should happen next. Menus update accordingly. Dependent choices can be refreshed. Previously hidden paths can reappear. Users remain free to experiment without becoming trapped by earlier decisions.
The authoring experience stays flexible while preserving contextual accuracy.
AI-Friendly by Design
Adaptive Source also enables entirely new authoring experiences. Organizations can use:
- internal recommendation systems,
- external services,
- machine learning models,
- large language models,
- domain-specific knowledge bases,
to determine which options should be presented during rule construction.
For example, an AI service could recommend the most relevant fields based on the rule being authored, restrict choices according to organizational policies, or guide inexperienced users toward preferred decision patterns. Prompted rule elements go one step further and call an LLM of your choice, including a self-hosted or local model, from within the rule elements themselves.
Importantly, the editor itself remains deterministic.
Your organization controls how guidance is generated and how much influence it has.
AI Next to the Editor, Not Instead of It
Code Effects 7 adds conversational authoring without giving up the menu-driven editor. In the Rule Repository, the AI Rule Editor sits alongside the standard Rule Editor: users describe the logic they need, or the change they want, in any language, and AI composes the rule. Every generated rule is checked against its source object, with validation results shown immediately, and users can move between conversational authoring and direct editing while keeping the latest rule.
The AI Assistant works across the entire rule database: it finds and explains rules, creates rules, versions, drafts and tests, runs tests, and answers questions about rules, recorded decisions and user activity. Both tools use the models your application registers, with your own API keys, under each user's permissions. See AI Assistant and AI Rule Editor.
The division of work stays clear: AI helps write the rule, the editor shows exactly what was written, the platform guarantees its structure, and people decide whether it expresses the intended policy. AI agents and services can never approve, delete, put a rule into production or take it offline, and every AI save requests approval.
Governance Without Friction
Ease of use should never come at the expense of control. Because the editor is embedded within your applications, organizations retain complete authority over:
- who can create rules,
- who can modify them,
- who can approve them,
- which source elements are exposed,
- how rules are stored,
- how changes are reviewed and tested.
The editor adapts to your governance model rather than imposing its own.
If you would rather not build that model yourself, the Rule Repository, new in Code Effects 7 and licensed separately, adds it inside your own application, on your own sign-in and against a database you own:
- Immutable rule versions, each linked to the source version it was written against, which users can compare and clone.
- Drafts for what-if ideas that never create rule versions.
- Tests on your real classes: exploration tests for what-if questions and expectation tests that pass or fail, each showing the decision path, saved and run in batches of up to 350.
- A decision workflow - request approval, approve or decline, Go Live, Take Offline - with typed confirmations and at most one live version per rule.
- Permissions your application supplies on every request, from a set of 37, with each step allowed only to the users you choose.
- Activity records and notes, so every change shows who made it and when.
With the optional Audit library, the production decisions those rules make can be found, replayed step by step and turned into tests as well.
Why the User Experience Matters
Many organizations evaluating rules technology focus almost exclusively on evaluation performance. But the true cost of decision automation is often determined long before a rule is executed. It is determined by how easily people can express, review, understand, and maintain the policies that govern the business. A rules engine may execute millions of decisions per second. But if the people responsible for those decisions struggle to define them, the technology never delivers its full value.
That is even more true when AI writes part of the logic. A rule nobody can read is a rule nobody can approve with confidence.
The Code Effects Rule Editor was designed around a simple principle:
Decision authoring should feel less like programming and more like explaining how the business works. Because the easier it becomes to express decisions, the faster organizations can adapt them.