Manager video
Governance for Enterprise Systems — Manager README Video Script
Script for the walkthrough of the Manager README. Target: under 10 minutes (~1,300 spoken words). Revised draft.
0:00 AI is top priority for state CIOs this year (NASCIO survey)
- And the first concern NASCIO lists is governance
0:11 Ideal - executable business prompts
1:40 With Native AI, we found issues of readability and trust
2:50 AI, Driven By Context Engineering to create rules (not code), provides governance
- Rules are the governance you can read, trust and maintain
5:23 Requirements are - and should be - incomplete
- So cannot be the system of record for verification and audit
- Rules are auditable and verifiable, and ~40x more concise
6:25 Project Governance Reports - logic utilization, visualization, and testing
- Requirements Traceability
7:20 Governance At Scale
- Existing methodologies result in governing rules, every project, every time
8:42 Enterprise Technology Automation for EAI, APIs, MCP, RBAC, Vibe UIs
10:00 Real enterprise projects created from a prompt
11:07 Drive collaboration across your Business Users and IT
- Using standard tools, and their preferred methodologies
- Bus User Friendly IDE
- Balances freedom with just enough support
- Including Requirements from AI Driven interview
This is walk-through of the product readme.
- Explore it via your browser using Codespaces (shown here): https://github.com/codespaces/new/ApiLogicServer/codespaces_mgr
- Or standard Python install: https://apilogicserver.github.io/Docs/
0. Opening (0:00–0:30)
Hi!
The number one priority for state CIOs this year, in the NASCIO survey, is AI — and the first concern NASCIO lists under it is governance.
Governance is often regarded as a process — reviews, sign-offs, a committee. Here it's automated, and for business logic, that means three things: read, trust, and maintain.
Let's explore that.
1. The Ideal (0:30–2:00)
Ideally, you supply a prompt to your AI, and it runs.
Here are five plain-English requirements for a credit check: a customer's balance is the sum of their unshipped orders, and it can't exceed the credit limit.
A few minutes later, you have a running app — screens, an enterprise-class API, and the logic, all in one containerized service. Think of it as hello world, for logic.
This constraint message is the result of a three-table transaction. That's governance in action.
What failed here was an edit to an existing order. But requirement said "when placing an order." Nobody wrote an update-time check. The business logic applies to all paths.
Let's explore how that logic was implemented.
2. AI Alone (2:00–3:45)
AI is genuinely good at UI, data mapping, boilerplate. Business logic is the exception.
We gave AI the same five requirements, without rules. Five requirements became about two hundred lines of procedural code. With rules, they are readable - 5 lines. A real system has orders of magnitude more — more than anyone can read, let alone audit.
On inspection, we found bugs. The code handled updates, but missed two re-parenting cases. Change an item's product, and the order wasn't re-priced. Move an order to another customer, and the old customer's balance was not adjusted.
Then we tried a typical spec — written the way a developer naturally writes it. Two frontier models, no rules. Both built the insert path. Neither built update or delete. The logic wasn't buggy so much as absent.
And regenerating for maintenance re-introduces the risk, and uses real resources.
We're deeply impressed with AI. This is about closing the gap it has here: logic.
So — how do we keep the speed and simplicity of AI, with the governance enterprises require?
3. Trustworthy and Auditable - AI Driven Rules
AI Driven Rules are a new piece of infrastructure, designed to create governed systems you can read, trust, and maintain. It has three parts:
First, AI translates intent — from plain English, Gherkin, even regulation text. That means you keep your existing methodologies, which promotes adoption.
Second, Context Engineering. It's injected into every project, and it drives AI to generate spreadsheet-like rules instead of code. Rules are the governance: deterministic, applied to every path.
Third, the rules engine enforces them at runtime. It listens to the database's ORM events, so every source — APIs, messages, agents — and every path — insert, update, delete — goes through the same commit point. There's no second door.
And it's not a Rete engine — those are built for decision logic. This one is built for transactions: it sees the actual change events and fires only the rules they affect.
Think of it like a DBMS: the rules are the DDL, the rules engine is the database server.
4. Declarative Rules Are Trustworthy
With procedural code, it's not always clear whether the code is called at all. If it is, it has to be sequenced properly. The hardest part is dependency management: when something changes, are the side effects handled?
Declarative removes those issues. The engine discovers the dependencies, orders the logic correctly, and chains the side effects — like a spreadsheet.
Shuffle the rules into any order, rerun, and it's still correct. There's no call to check_credit anywhere — nothing calls it. Rules are declarative ("what"), not procedural ("how").
So if you see a rule, you can trust that it runs, and in the right order.
With rules, seeing really is believing.
5. Rules are the Governance you can Read and Trust
Natural-language requirements are — and should be — a sketch, not complete. That's exactly what you want to hand to a capable collaborator: not every detail spelled out, just enough for them to do what you meant, not merely what you said. AI is good at that. No artificial syntax to learn.
But that same incompleteness is why natural-language requirements can't be the system of record. An auditor needs something rigorous and complete to check against.
Rules can be that record. They're readable — a fraction of the procedural equivalent. And they're trustworthy: an auditor isn't tracing execution paths or dependency chains, or wondering whether some code never got called.
Governance by architecture, not by discipline. Discipline means every developer, on every change, has to remember the right pattern. Architecture means the software does it automatically.
6. Project Governance
Resolving ambiguities is valuable, but carries a responsibility: documenting presumptions.
The AI Alerts report lists those judgment calls. And for anything with no safe default, it stops — no code written, a marker left, the options listed for a person to decide. You review the judgment calls, not the code.
A logic flow diagram, generated from the running rules, lets a compliance reviewer check the implementation in minutes.
The Health Check report provides metrics on rule utilization.
And the test report traces requirement, to test, to rule, to the execution log — before and after values — in one place.
7. Governance at Scale
Governance depends on rules — they're what you can read, trust, and audit. But the manual discipline to keep using rules, not procedural code, is hard to sustain across projects.
Here, the architecture produces the rules. Whatever the requirement format, Context Engineering directs the AI to generate rules, not code. No team has to remember to choose them. Rules are what comes out.
That typical spec again: native AI built the insert path and dropped update and delete. Fed to this pipeline, it produced five rules covering all nine paths. Same input, same AI. The difference was the AI Driven Rules architecture.
And it repeats: these samples have been run hundreds of times, and the output is always rules. The Context Engineering knows the patterns, not just the syntax.
And every project gets the same reports, so governance is visible across the portfolio — without reading a line of code.
8. Enterprise Architecture, in Brief
The system is a scalable server, deployed as a standard container, and the same rules govern everything that touches it.
That includes enterprise integration: B2B partner orders arrive by custom API or Kafka, and go through the same rules.
The APIs are discoverable through MCP, so a business user can ask for new functionality, like emailing customers with overdue orders - without IT support - with full rule governance.
Logic-enabled APIs provide the perfect backdrop for creating custom UIs, using your favorite vibe tools. Built-in support for RBAC ensures users see only the rows authorized for their roles.
If requested, Logic Using AI can reason at runtime. "Find the optimal supplier" can reason about world conditions, like a Suez Canal blockage. But the AI only proposes. The same deterministic rules decide, and the decision is audited.
9. Enterprise Results
That architecture is what created these three enterprise-class systems. Prompt-to-app tools build the screens; these are complete systems — the API, the Admin App, and the hard part: business logic governed by rules. Each was created from the requirements its team already writes.
The first is cascading cost allocation, two levels deep — complex logic from this prompt. The manual effort failed to deliver, reportedly by four developers over two years.
The second is Canadian customs duties. This prompt reads the actual web-based regulations, in business language, not rules... one practitioner who tried it estimated it replaced a project of about a person-year.
The third screens dangerous goods, from Gherkin requirements — the rules caught audit failures missed in a multi-year effort.
Three different promps, all resulting in running systems, governed by rules, no bypass.
10. Business Users and IT Collaboration
Since AI can translate virtually any intent, your team can continue to use existing methodologies.
Business Users can use natural language, with a business oriented view provided by the same IDE and the same files the developers use. So, hitting a complexity wall does not mean a restart and finger-pointing - developers can build out the system using familiar tools. Collaboration, not finger-pointing.
There's no proprietary studio and no rigid structure. You keep your own methodology, and you never face a blank page: ask the AI for guidance when you need it — or ask it to interview you to work out the requirements. A perfect balance of flexibility and structure.
11. Close
Fast, and better — governed, enterprise-class systems, built by business users and developers from one artifact. It's free and open source; the README walks you through the created systems, and illustrates how to recreate them.
LinkedIn post (proposed intro for the video)
Many assume AI will get good enough that the prompt becomes the system of record and generated code is just compiler output. We hope so.
But even if it does, governance needs something you can read and check. Requirements are, and should be, incomplete. Code is complete but unreadable at scale.
Rules generated from prompts are complete, readable, and trustworthy.
Many also govern the process: reviews, sign-offs, a committee. But what matters is the result: your business policy, enforced automatically on every transaction. Rules are that governed business policy.
A 12-minute walkthrough, with three real systems built from prompts.
Post as a native LinkedIn video upload (same file as YouTube; captions: video.clean.srt). First comment, with the links:
Try it in your browser (Codespaces): https://github.com/codespaces/new/ApiLogicServer/codespaces_mgr Or a standard Python install: https://apilogicserver.github.io/Docs/ Same video on YouTube, with chapters: https://youtu.be/4pLAvWW9Pik
Video , Trest ust 1, Trust 32, Maint
- Reastart: start: Gov > TrustGov, Opeen,
- TresuustProj Gov & Auitdit *(ADR) Sys > Trustworthy
-
Proj Gov, AL AO I Alerts, Logic Flow, Health CHeckheck, Tessstssts
-
Gov a Scale -- sc, scroll to diagram (automaictic prderordering), Arch/Diacipline
-
Proj Gov, AI Alerts, Logic Flow, Health Check, Tests
7 > RUle ulses are Gov (intent comincp, Arch/Dicipline, then code
- Restart: Ent Arch > E-class , Ent Arch, B2B, MCP, Voive, be,
- Close 8, open Reslults, each sample (3)
- Reatarstart: Collab, each
- Close - chose 1 screen