EWB: a proposal for integrating a programming language with an AI preprocessor

The problem is not asking a question

An assistant can generate code in almost any language. The quality of its answer, however, depends on what it knows about the project: its architecture, contracts, style, previous decisions and known pitfalls. Copying a question into a chat and rebuilding that context every time is both fragile and expensive.

EWB therefore introduces a request directly into the source code:

AI("generate the code required for this operation")

This is not a call performed by the final application. It is a formal instruction intended for the ewIA preprocessor.

What ewIA does

The AI("request") instruction is a formal request addressed to the assistant. The ewIA preprocessor:

• locates the request within the program;
• collects the relevant technical context;
• attaches documentation, AGENTS.md files and the project organizer;
• describes the project's constraints, conventions and current state;
• sends the complete package to the assistant;
• places the proposal back into the source code, clearly marked and commented out;
• leaves the decision to accept it to a human.

The assistant therefore receives more than an isolated sentence: it receives the information required to interpret that sentence according to the actual contracts of the system.

A language that can prepare its own context, so the assistant does not answer like a tourist.

Why a preprocessor?

A preprocessor keeps the use of AI optional and separate from program execution. The programmer expresses the request with a single instruction, but the answer does not silently become part of the code: it is produced before compilation, remains visible and can be reviewed, corrected or rejected.

This separation also keeps the implementation simple. Neither the compiler nor the VM needs to know about models, protocols or external services. They only need to recognize an unresolved AI() request and report the explicit AI section not implemented exception instead of hiding it behind a generic syntax error.

The result combines ease of use, human control over generated code and independence of the final program. Developers who do not want to use ewIA acquire no dependency; those who do use it can see exactly which section was proposed by the assistant before accepting it.

Generation, not dependency

The model is queried once, during development. The VM does not contain an LLM, and the deployed program does not depend on the service that produced the proposal. Once accepted, the result is ordinary EWB code: readable, versionable and deterministically executable.

This separates three responsibilities: the programmer states the intent, ewIA builds the context, and the assistant proposes an implementation. The decision remains human. A surprisingly civil separation of powers, considering our moderate plans for world domination.

From EWB to other languages

The mechanism currently works for EWB, but it does not depend on EWB syntax or on its VM. The same model could be applied to any language: it requires a preprocessor capable of recognizing a request, collecting context and placing a proposal back into the host language's source format.

The decisive part is not the model call. It is the knowledge base that accompanies the request: actual documentation, operating rules, conventions, project state and an organizer maintained over time. With adequate material, the preprocessor can give the assistant what an isolated prompt normally lacks. Without that care, the only achievement is automated improvisation.

EWB and ewIA are therefore both a concrete, working implementation and a broader proposal: integrate assistance into a language's development process without making AI a required component of the resulting program.

A distinct feature

There are languages for orchestrating model calls, languages designed to be generated by LLMs, and development environments that read project instructions. The EWB model is different: the generation request belongs to the source code, the preprocessor gathers local knowledge, and the result returns to the source as a proposal awaiting approval.

According to the publicly available material found by the date of this article, EWB is the first programming language to integrate an AI() instruction with this specific cycle of context-aware generation and human review. This claim is deliberately verifiable and can be corrected if a documented earlier example emerges.

Read and discuss this article on LinkedIn →