Leverage AI Across the SDLC for Speed with Governance and Verifiability

In this article, we explain how to use AI for dramatically improving velocity across the Software Development Life Cycle (SDLC).

There are remarkable AI Coding Tools, such as Gemini, CoPilot, Cursor, All Hands, etc.. But, there are key gaps which we will explore:

• Scope: existing tools can create screens or functions, but typically do not create complete systems

• Business Logic: in particular, multi-table business logic, is not addressed; this is significant, since such logic typically requires nearly half the effort.

We will also explore some of the concerns about using AI, such as hallucinations and their potential impact on data integrity.

Gaps: Scope (screens/functions vs. Full System), Business Logic

Scope: Full System

Creating functions and screens is required and valuable.  These need to be coupled with 'up front' creation of complete systems: a test database, an app, and an API.

If we could create a system in a minute, then we could quickly share running screens with users to be sure we have the requirements right. Then, we could immediately identify any systems that didn't deliver the desired business value.

Now we can.  

GenAI-Logic combines GenAI with declarative automation of admin apps and APIs.  It enables you to create complete running systems in 1 minute, with prompts such as:

 Create a system for Customers, Orders, Items and Products

Or:

  Create a Time Tracking System for Clients, Projects, and Tasks,
with Invoice Creation

Business Logic (half the effort): unique declarative rules which are 40X more expressive than code.

Good start.  But business users typically describe the system in terms of its business purpose, e.g., to compute Order pricing and check credit.  

That's business logic.  It's nearly half the effort of transactional systems.  And existing products simply provide a 'your code goes here' approach, often with proprietary scripting languages and IDEs.

 GenAI-Logic includes a rules engine that automates multi-table derivations and constraints from spreadsheet-like declarative rules.  Rules are a remarkable 40X more expressive than code.  You can declare the rules in Natural Language, or use your IDE.

So, we can expand the first system:

Create a system for Customers, Orders, Items and Products
  Use Case: Check Credit
    1. Verify the Customer Balance is less than the Credit Limit

  2. The Customer's balance is the sum of the Order amount_total where date_shipped is null

  3. The Order's amount_total is the sum of the Item amount

  4. The Item amount is the quantity * unit_price

  5. The Item unit_price is copied from the Product unit_price

Use case: App Integration

    1. Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None.

This also runs in 1 minute.

Iteration

It's rare to get things right on the first try.  In fact, any creative endeavor is a cycle of create, review, iterate.  Software development is more so, often involving a team of stakeholders.

So iteration is baked into the process.  You can add new tables ("wait!  customers have multiple addresses"), rename ("can we rename Customer to Account?").

Concerns

With any new technology, the trick is to provide value:

• without gotcha's

• without compromising existing tools and techniques

Governance: GenAI-Logic creates a standard project to verify and customize

Without a doubt, the biggest concern with AI is hallucinations: creating wrong results.  This is particularly unacceptable if the system is responsible for enforcing the integrity of valuable corporate data.  Creativity is not a feature for payroll processing!

GenAI-Logic uses GenAI in the creation process, only.  It is not active during execution.

The creation process results in a standard project you can open in your IDE.  This enables you to review what is created and fix any issues.  For more information, see  GenAI Governance.

Creating complete systems does not imply they are finished.  Automation must accept that customization will always be required.  Standard projects enable exactly such customization, using standards as described below.

Full Flexibility With Standards: database, language, tools, deployment

To deliver velocity, many products use proprietary databases, languages, and tools.  This can work fine for simple work-group projects, but even moderate-sized projects require customization.  Proprietary tools can limit customization, and build developer resistance ('you will have to pry my debugger out of my cold, dead hands').

GenAI and Automation should not compromise standards or flexibility.

GenAI-Logic creates standard Python projects.  Download them, and customize in your favorite IDE.  Use all your familiar tools for code editing, debugging, source control, etc.

In particular, a standard project / language enables the use of the new breed of AI Coding Tools, such Gemini, CoPilot, Cursor, All Hands, etc.  

Use these for:

• custom APIs - complement the JSON:APIs with your own

• custom screens - complement the Admin App with your own

• custom Logic (via familiar events)

Maintainability - no archaeology, no FrankenCode

Both for iterative development or maintenance, change is expensive.  And it's not fun.  Developers want to write code, but need to spend time performing "archaeology" on existing code to find where to insert their changes.

This painful reality is eliminated by declarative code: business logic is automatically ordered, per system-discovered dependencies.  So, you just insert new rules (or change existing ones) wherever they make sense.

Maintenance / iteration requires you understand existing code.  Developers often hate code generators, since they create enormous volumes of code that are difficult to understand.  FrankenCode!

Business logic eliminates this problem.  The declarative rules (representing what, not how), are 40X more expressive than procedural code. 

As you can see below, GenAI translates a line of logic into 1 Rule line, not 40 lines of Python:

Verifiability, Debugging

When working with a favorite architect friend, our most cutting criticism for a piece of sotfware was: "what is it doing now?"  Systems must be transparent, particularly ones based on automation.

The screenshot below illustrates 2 key tools for verifiability:

1. Debugger: use your standard IDE debugger to stop, examine your variables, and step

2. Logic Log: automated business rules provide a detailed log, depicting every rule that fires.  The indentation represents rule chaining between tables (e.g., the item adjusts the product unitsshipped. )

   • Note: this is a different example than shown above

Auditing: Logic Log

In addition to debugging, such logging is particularly valuable to demonstrate system operation to auditors.  You simply must be able to answer the question: How was that result obtained?

Testing: Standard Tooling, Behave BDD Framework

Large scale regression testing is required for any system, regardless of how it is created.  Since the language is standard Python, you can use standard test tooling.

Or, optionally, GenAI-Logic incorporates Behave, a Behavior Driven Design tool.  You can use it to:

• Document requirements as tests

• Run all of the tests as a test suite