DEV Community: Kanwal Oswal

The Return of the CLI: Faster for Humans, Native for AI

Kanwal Oswal — Sat, 28 Mar 2026 14:07:09 +0000

For a decade, we were told the "User Experience" lived in the browser. But as systems grew complex, dashboards became a clicking nightmare. Today, the CLI is back—not because we’re nostalgic or want to feel 'cool' and 'techie', but because it’s the most efficient interface for humans and the native language of AI agents.

Why CLI? Why Now?

In an era of Platform Engineering, the CLI is the ultimate abstraction.

Composability: You can’t pipe a React button into a database migration script.
Agent-Readiness: Large Language Models (LLMs) struggle with fluctuating DOM elements in a GUI but thrive on structured CLI output.
Speed: Moving your hand to a mouse is a latency hit. For a senior dev, the terminal is a high-bandwidth low-latency connection to the machine.

Python: The Speed of Thought

Python is the "gold standard" for CLIs because of its readability and the incredible library support. If you're still using argparse, you're working too hard.

The Modern Stack: Typer

Typer (built on Click) uses Python type hints to generate help screens and validations automatically.

import typer

def main(name: str, formal: bool = False):
    if formal:
        typer.echo(f"Greetings, Distinguished Colleague {name}.")
    else:
        typer.echo(f"Hey {name}!")

if __name__ == "__main__":
    typer.run(main)

Run this without and arg and see and then with the arg.
Pro-Tip: Use Rich alongside Python CLIs to render beautiful tables and progress bars that make the terminal feel like a high-end dashboard.

Java: The Enterprise Workhorse

Historically, Java was "too slow" to start for CLI tools. With GraalVM Native Image, that’s over. You get the type safety of Java with the startup speed of C++.

The Modern Stack: Picocli

Picocli is tiny but mighty. It handles everything from ANSI colors to autocomplete.

@Command(name = "checksum", mixinStandardHelpOptions = true, version = "1.0")
class Checksum implements Callable<Integer> {
    @Parameters(index = "0", description = "The file to check")
    private File file;

    @Override
    public Integer call() throws Exception {
        byte[] fileContents = Files.readAllBytes(file.toPath());
        System.out.println(DigestUtils.md5Hex(fileContents));
        return 0;
    }
}

Architect's Note: Use Picocli when building internal tools that need to tap into your existing Enterprise Spring Boot or Jakarta EE logic.

Windows and the CLI: No Longer a Second-Class Citizen

The days of struggling with cmd.exe are dead. The Windows Terminal and PowerShell 7 (Core) have unified the experience.

Object-Oriented Piping: Unlike Bash (which passes strings), PowerShell passes objects.
- ls | where {$_.Length -gt 1mb} — This doesn't just parse text; it filters file objects.
Winget: The Windows Package Manager has finally made environment setup scriptable.
- winget install JanDeDobbeleer.OhMyPosh — Use this to make your Windows prompt look as good as any macOS Zsh setup.

The "Cool" Factor: More Than Just Text

Modern terminals support TrueColor and Unicode symbols. You can create sophisticated visuals without a single pixel of CSS.

ASCII & Rich Visuals

Using tools like Art in Python or simple Unicode characters, you can create "Status Dashboards" that live in the terminal.

  _________________ 
< CLI is the Future >
  ----------------- 
         \   ^__^
          \  (oo)\_______
             (__)\       )\/\
                 ||----w |
                 ||     ||

3 Practical Tips for Your Next CLI

Idempotency is King: A CLI command should be safe to run twice. Check state before acting.
Standard Out vs. Standard Error: Send your logs to stderr and your data to stdout. This keeps your pipes clean.
JSON Output Mode: Always provide a --json flag. This is how you make your tool "Agent-Friendly" so an AI or a script can consume the output without "regex-ing" your text.

The CLI isn't a step backward; it's a pivot toward automation.

Here is the 'cowsay' generated code (Thanks Gemini)

def simple_cowsay(message: str):
    # 1. Calculate the bubble width
    length = len(message)
    line = "_" * (length + 2)
    border = "-" * (length + 2)

    # 2. Build the speech bubble
    bubble = [
        f"  {line}  ",
        f"< {message} >",
        f"  {border}  "
    ]

    # 3. The Cow (using double backslashes to escape them)
    cow = [
        r"         \   ^__^",
        r"          \  (oo)\_______",
        r"             (__)\       )\/\ ",
        r"                 ||----w |",
        r"                 ||     ||"
    ]

    # Combine and print
    print("\n".join(bubble + cow))

simple_cowsay("CLI is the Future")

Stop Asking LLMs “Does This Pass?” — Turn Policies Into Executable Rules Instead

Kanwal Oswal — Thu, 19 Mar 2026 02:06:24 +0000

If you’ve worked with LLMs in real systems, you’ve probably tried something like this:

“Here’s a policy document. Here’s some input data.

Does this meet the policy?”

It works surprisingly well… at first.

But as soon as you move beyond demos, a few problems start to show up:

Results vary depending on phrasing or context
It’s hard to explain why a decision was made
The only audit trail is prompt + response
Re-running the same input doesn’t always guarantee the same output

This becomes a real issue in domains like:

financial services
compliance
eligibility systems
underwriting

Where decisions need to be consistent, explainable, and auditable.

The Core Problem

The issue isn’t that LLMs are bad.

It’s that we’re using them for the wrong part of the workflow.

We’re asking them to evaluate policies repeatedly at runtime, instead of using them to extract structured logic once.

A Different Approach

Instead of:
Policy Document + Input Data → LLM → Decision

What if we did:
Policy Document → LLM → Structured Rules
↓
Deterministic Engine
↓
Decision + Trace

This is the idea behind AeroRule.

👉 GitHub: https://github.com/kanwaloswal/AeroRule

What is AeroRule?

AeroRule is a lightweight rules engine designed around:

JSON-based rule definitions
CEL (Common Expression Language) for conditions
deterministic evaluation
traceable outputs

It’s built to be:

safe for LLM-generated rules
easy to integrate (Java + Python)
suitable for audit-heavy environments

The goal is to decouple business logic from code while keeping it safe and explainable.

Example Rule

Here’s what a rule looks like:

{
  "id": "CREDIT-001",
  "description": "Minimum credit score requirement",
  "condition": "customer.creditScore >= 680",
  "onSuccess": { "action": "PASS" },
  "onFailure": { "action": "DECLINE" }
}

Simple, readable, and structured.
The condition is written in CEL, which is:

safe (non-Turing complete)
fast
easy to sandbox

Why Traceability Matters

In many systems, it’s not enough to know what happened.

You need to know:

what inputs were used
what condition was evaluated
whether it matched
what action was taken
how long it took

This is critical for:

debugging
audits
compliance reviews

Rule Sets: Real Policies, Not Just Rules

Real-world policies aren’t a single condition. They are a sequence of checks.

AeroRule supports RuleSets, for example:

{
  "executionStrategy": "GATED",
  "rules": [
    { "condition": "customer.creditScore >= 680" },
    { "condition": "customer.annualIncome >= 40000" }
  ]
}

With strategies like:
ALL → evaluate everything
GATED → stop on first failure

This lets you model real decision flows like loan approvals.

Where LLMs Fit In

LLMs are still incredibly useful — just in a different role.

Instead of evaluating decisions, they:

👉 convert natural language → structured rules

AeroRule includes a demo app that:

takes a policy document
generates rules using an LLM
links rules back to source text
allows interactive evaluation

This creates a pipeline like:

Human Policy → LLM → JSON Rules → Deterministic Engine → Traceable Decision

If you’re interested, check it out:
👉 https://github.com/kanwaloswal/AeroRule

Feedback, ideas, and contributions are welcome.