Forem: edwin realpe preciado

I built a protocol that reduces AI prompts by 70% — here's the proof

edwin realpe preciado — Mon, 18 May 2026 13:29:09 +0000

The claim

Most developers know that AI prompts are
inconsistent. You write 80 words describing
a component, the AI generates something
close but not quite right, you iterate,
you waste time.

I've been working on a different approach:
instead of writing better prompts, what if
you had a structured protocol that eliminates
the ambiguity entirely?

That's NEXUS — a minimalist Human-AI
communication protocol. And instead of
just claiming it works, I built a library
of 25 real examples showing the before
and after.

The comparison

Here's a real example — a webhook handler:

Without NEXUS (87 words of natural language):

"Create a POST endpoint in Express to receive
Stripe webhooks. It should read the body as
raw buffer, verify the webhook signature using
stripe.webhooks.constructEvent() with the secret
from environment variables, return 400 if the
signature is invalid, and call
WebhookService.handleStripe() with the event.
Respond with received: true if everything works."

Result: variable. Depends on the model,
the day, the context.

With NEXUS (8 lines):

@Express
Controller WebhookController
  Router ApiV1
    Endpoint POST /webhooks/stripe
      !! "La firma del webhook debe ser válida"
      => WebhookService.handleStripe()
      !error:400 -> /error/invalid-signature

Result: deterministic. Every time.

The numbers across 25 examples:

Average reduction: ~70% less text
Ambiguity: zero
The AI knows exactly what to build

Why it works

Natural language compresses intent into
sentences that humans parse easily but
AI models resolve inconsistently.

NEXUS makes intent explicit:

!! preconditions fire before the action
!error:code handles failures after
=> is the action — nothing implied

The model doesn't decide what to do.
The protocol tells it.

See the 25 examples

I built a full library showing the
three-panel comparison for every example:

Natural language prompt (what you'd write today)
NEXUS blueprint (8-16 lines)
Generated code (the output)

Cards, navbars, forms, REST APIs,
authentication flows — all with the
before/after numbers.

👉 nexuslang.dev/examples

The library is open source:
💻 github.com/open-souse/Nexus
📦 npm install nxlang

Curious what examples you'd want to see
next — what's the most painful component
to describe to an AI in natural language?

The hidden cost of implicit preconditions in AI prompts

edwin realpe preciado — Sun, 17 May 2026 14:19:28 +0000

The problem nobody talks about

You write a prompt to an AI. It looks correct.
It's clear, detailed, well-structured. And yet
the output is inconsistent — sometimes it does
what you want, sometimes it doesn't, and you
can't figure out why.

The issue usually isn't the model. It's a
structural problem in how natural language
communicates intent.

The two-step instruction problem

Consider this instruction:

"If the product is not in the catalog,
tell the customer we don't have it."

Simple, right? But this single sentence
actually contains two steps:

Precondition: search the catalog and confirm the product is absent
Behavior: reject honestly

Natural language compresses both into one
sentence. Humans read it and instantly
understand the implied sequence.
AI models don't always.

Depending on the architecture, the model might:

Execute the rejection without checking first
Check but apply the rule in the wrong order
Resolve the ambiguity differently each time

The instruction was ambiguous before any
model ever read it. The model just revealed
the ambiguity.

Why this matters more than you think

Every time you write a prompt with an
implicit precondition, you're betting that
the model will infer the correct sequence.

Sometimes it does. Sometimes it doesn't.
And when it doesn't, you spend hours
debugging what looks like a model failure
but is actually a language failure.

Examples of implicit preconditions hiding
in plain sight:
"Only show the checkout button if the cart
is not empty"
→ Precondition: verify cart state FIRST
"Send a confirmation email after the user
registers"
→ Precondition: confirm registration SUCCESS first
"Reject the request if the user doesn't
have permission"
→ Precondition: check permissions BEFORE processing

All of these look unambiguous. None of them
explicitly tell the AI to verify the condition
before acting.

The solution: make preconditions explicit

What if preconditions weren't buried inside
natural language instructions? What if they
were a first-class citizen of the protocol?

That's the core idea behind the !! operator
in NEXUS — a minimalist Human-AI communication
protocol I've been building.

Instead of:
"Process the checkout if the cart is not empty
and the user is authenticated and stock is available"

You write:

Endpoint POST /checkout
  !! "Cart cannot be empty"
  !! cart.items.length > 0
  !! user.authenticated
  => OrderService.create()
  !error:400 -> /error/validation
  !error:401 -> /login

The model doesn't decide whether to reject.
It generates a response on the happy path,
and the protocol handles absence elsewhere.

The preconditions aren't instructions the
model interprets. They're contracts the
protocol guarantees.

What this changes

When preconditions are explicit:

A human can audit intent without running the model — just read the !! lines
The model has no decision to make about sequence — it's already encoded in the structure
Architecture sensitivity disappears — MoE or Dense, the structure is the same
Debugging becomes trivial — if something fails, you know exactly which precondition wasn't met

The asymmetry that makes it work

NEXUS separates two things that natural language
conflates:
!! precondition → what must be true to continue
!error:code → what to do when something fails

Preconditions fire before. Errors handle after.
The model never has to figure out which layer
it's in.

Try it

NEXUS is open source. The !! operator shipped
in v4.2.0 with 154 tests and full documentation.

npm install nxlang

If you've ever spent hours debugging a prompt
that looked correct but behaved inconsistently —
this might be worth 10 minutes of your time.

🌐 nexuslang.dev
💻 github.com/open-souse/Nexus
📦 npmjs.com/package/nxlang

Have you run into this problem? How do you
handle implicit preconditions in your prompts?
I'd love to hear how others are solving this.

I built a minimalist protocol to communicate with AI without ambiguity

edwin realpe preciado — Sat, 16 May 2026 01:08:19 +0000

The problem

Every developer who works with AI knows this frustration:
you write a long, detailed prompt, and the AI generates
something that's almost right but inconsistent,
over-engineered, or missing critical details.

The problem isn't the model. It's the language.

Natural language is ambiguous by design. What's obvious
to you has ten possible interpretations for an AI.

The solution: NEXUS

NEXUS is a tachygraphic protocol — structured shorthand
that compresses complex software architecture into
precise, unambiguous intent.

Instead of writing:

"Create a modern dashboard with authentication,
analytics charts, user management, real-time
notifications, dark mode, responsive design..."

You write:

@React @Tailwind
Page Dashboard
  @Auth[mode:jwt]
  Layout SplitView
  Section Analytics #glass
    Chart < MetricsData [paginate:10]
  Section Users
    Table < User !bold
      !error:404 -> /not-found

8 lines. Zero ambiguity. The AI knows exactly what
to build.

What NEXUS is (and isn't)

NEXUS is not a programming language. It doesn't
replace JavaScript, Python, or any other language.

It's the communication layer between human intent
and AI generation. You write NEXUS, the AI generates
the real code.

How it works

// Frontend
Page ProductDetail
  Layout Stack #gap-2
  Section Hero
    Image < product.thumbnail [ratio:16/9]
    Text < product.name !bold !xl
  Section Actions
    ( product.inStock ) ->
      Button "Add to Cart" => CartStore.add(product)
    :
      Badge "Out of Stock" #muted

// Backend
Model Order
  Entity id !pk
  Entity status default:pending
  Entity user -> Model.User
  Entity items -> Model.Product [many]

Controller OrderController
  Router ApiV1
    Endpoint POST /orders => OrderService.create()
      !error:400 -> /error/bad-request
      !error:500 -> /error/server

The library

nxlang is the open source TypeScript library that
implements the protocol:

validateNexus() — validates syntax in real time
buildSystemPrompt() — generates the AI context
createDefaultConfig() — project DNA configuration

npm install nxlang

135 tests passing. Library-first architecture so you
can embed it in your own tools and editors.

Beyond code

The three primitives of NEXUS are universal:

@ Directives — define context (@React, @Legal, @Scientific)
# Tokens — define labels (#urgent, #primary, #confidential)
-> => Relations — define flows and actions

The protocol was designed for code but the problem it
solves exists in every industry that uses AI.