Exploring Script.ai

A Conceptual Experiment in Human-Readable Code for the AI Era

Abstract

As artificial intelligence increasingly takes on the role of writing code, the dynamics of software development are shifting, with more non-technical individuals participating in the creation of applications alongside AI tools. This raises an important question: how can we make AI-generated code more understandable for people without in-depth programming knowledge? To explore this, I proposed an idea called Script.ai, a verbose, English-like programming language designed to enhance the readability of AI-generated code for human reviewers. I discussed this concept with Grok 3, an AI developed by xAI, and together we embarked on an exploratory journey to evaluate its potential. Through our conversations, Grok 3 created several versions of a transpiler to convert JavaScript/TypeScript into Script.ai, allowing us to test and refine the output. This article details our exploration, the reasoning behind Script.ai, its potential benefits and trade-offs, and presents examples generated by our transpiler to spark discussion and gather feedback on the idea.

Introduction

The landscape of software development is undergoing a profound and rapid transformation, driven by the remarkable advancements in AI-driven code generation. Today, AI tools are assisting professional developers and empowering a growing number of non-technical individuals to create applications with unprecedented ease.

For example, I recently conducted an experiment with Windsurf, a tool that leverages AI to generate code. As a first-time user, I provided Windsurf with just a single paragraph of information, including a bare-bones description of the underlying data structure I wanted to expose through a web API. Forty minutes later, without writing a single line of code, I had a published API complete with authentication, documentation, and test case scripts. The application was running, automatically tested using scripts the AI created, and I could access the underlying database—also created by the AI—to verify the stored data. Was the application ready for production? No. Was it perfect? No. But its shortcomings stemmed from the limited information I provided; AI is fantastic, but it’s not magic.

In a real project, I would have given it much more detail than a single paragraph. This experience, however, underscores just how quickly software development is shifting, enabling people with minimal technical expertise to build functional applications in a fraction of the time it once took.

This democratization of software development means that more people—including product managers, domain experts, small business owners, and citizen developers—are participating in the creation and review of code. However, this shift comes with a significant challenge: AI-generated code must be reviewed and understood by humans, many of whom may lack in-depth programming knowledge.

Traditional programming languages like JavaScript, Python, and C++ prioritize conciseness and machine efficiency, often using symbols (e.g., +=, &&) and compact constructs that can be difficult for non-experts to understand at a glance. Historically, this conciseness was driven by programmer productivity—sometimes referred to as "laziness"—as developers sought to write code more efficiently. But in an era where programmers are no longer typing out the commands, and as much as 100% of the code may be written by AI, this rationale becomes moot. Instead, the focus shifts to ensuring that the code is understandable to reviewers, who may include non-technical stakeholders or developers unfamiliar with the language or codebase.

In a scenario where all code is AI-generated, a person familiar with basic programming concepts—or even just logical reasoning and problem-solving skills—would likely find it easier to understand a representation closer to English than JavaScript, for example.

This realization inspired me to explore a new idea: what if we could translate AI-generated code into a format that prioritizes human readability, especially for those without in-depth programming knowledge?

I decided to discuss this concept with Grok 3, an AI developed by xAI, to explore its pros and cons and to see what such a language might look like. Through our conversations, Grok 3 was incredibly helpful in refining the idea, proposing solutions, and ultimately creating several versions of a transpiler to convert JavaScript/TypeScript into a new language we called Script.ai. I tested the output of each version, and we discussed how to make it more understandable, iterating on the design to better serve its purpose. This article presents our exploration of Script.ai, a verbose, English-like programming language designed to make AI-generated code more accessible to human reviewers, and invites feedback on the concept.

Motivation and Conceptual Exploration

The motivation for Script.ai stems from the evolving role of humans in software development, particularly as AI becomes more integrated into the process. Today, AI tools are assisting professional developers and empowering a growing number of non-technical individuals to create applications. For example, a product manager might use an AI to generate a prototype, a small business owner might build a simple app without hiring a developer, or a hobbyist might create a tool to solve a personal problem. This trend is accelerating as AI models become more capable and accessible, enabling people without in-depth programming knowledge to participate in software development.

However, this democratization comes with a challenge: AI-generated code must be reviewed and understood by humans, many of whom may not be familiar with traditional programming languages and their syntax. Even for experienced developers, reviewing AI-generated code in an unfamiliar language or codebase can be time-consuming. To address this, I envisioned Script.ai as a language that translates AI-generated code into a verbose, English-like format, making it more accessible to a diverse audience, including:

• Non-technical stakeholders: Product managers, domain experts, or business owners who need to understand the logic of AI-generated code.

• Citizen developers: Individuals with limited programming experience who are using low-code, no-code and now AI to build applications.

• Experienced developers: Professionals reviewing unfamiliar codebases or AI-generated code in a language they are not familiar with.

I decided that I should discuss this idea with an AI and brought it to Grok 3, and through our discussions, we explored the pros and cons of such a language. The AI proposed creating a transpiler to convert JavaScript/TypeScript into Script.ai, allowing us to test the concept and evaluate its output. What’s remarkable about this process is that I didn’t need to use a specialized developer-focused tool like Cursor or Windsurf to achieve this. Instead, a regular conversation with Grok 3 was sufficient to explore the idea, generate a transpiler, and evaluate its output, demonstrating how far AI has come in supporting code generation through natural language interactions. After deciding to implement the transpiler using Node.js, Grok 3 generated several versions, each of which I tested to assess the readability of the output. Together, we iterated on the design, discussing how to make the language more understandable for human reviewers.

Design Principles

Our exploration of Script.ai was guided by the following principles:

1. Verbosity for Clarity: Replace concise operators and syntax with English-like phrases to make the code self-explanatory. For example, sum += num becomes Add num To sum.

2. Explicit Structure: Use clear, structured constructs to delineate the beginning and end of blocks (e.g., If Condition ... Then and End If) and mark instructions with semicolons for clarity, except within block constructs where the structure itself provides clarity.

3. Preserve Evaluation Order: For compound logical expressions, translate operators to words (e.g., && to And, || to Or) and use parentheses to make the order of evaluation explicit, ensuring reviewers can follow the logic without ambiguity.

4. Balance Readability and Familiarity: Translate simple comparisons and logical operators to words (e.g., > to Is Greater Than, && to And), but preserve operators in complex mathematical expressions (e.g., sum * (1 + 2) / numbers.length) to avoid excessive verbosity which would end up making the expression harder to understand, not easier.

5. Support for Common Constructs: Handle essential programming constructs like functions, loops, conditionals, and object literals, ensuring Script.ai can represent a wide range of AI-generated code.

Examples of Script.ai in Action

To explore the concept of Script.ai, Grok 3 created a transpiler that converts JavaScript/TypeScript code into Script.ai. Below are two examples that showcase the language’s capabilities, generated using the current version of the transpiler. These examples are intended to spark discussion and gather feedback on the idea.

Example 1: Summing Positive Numbers

Let’s consider the following JavaScript function that sums positive numbers in an array.

Original Javascript code:

function calculateSum(numbers) {
    let sum = 0;
    for (const num of numbers) {
        if (num > 0) {
            sum += num;
        }
    }
    return sum;
}

const values = [1, -2, 3, -4];
const total = calculateSum(values);
console.log(total);

When processed by the Script.ai transpiler, this code is translated into:

Define Function calculateSum(ByRef numbers As Array Of Numbers) Returns Number:
    Set Variable sum As Number To 0;
    For Each num In numbers:
        If Condition num Is Greater Than 0 Then
            Add num To sum;
        End If;
    End For;
    Return sum;
End Function;

Define Main Script:
    Create Array values As Array Of Numbers With Elements [1, -2, 3, -4];
    Call Function calculateSum With Argument values And Store In Variable total
      As Number;
    Call Function log On Object console With Argument total;
End Script;

Overview of the Notation

Here is a quick summary of what is happening in transforming this first example code:

• Function Definition: function calculateSum(numbers) becomes Define Function calculateSum(ByRef numbers As Array Of Numbers) Returns Number, making the function’s parameter’s type explicit and also making explicit how each parameter will be handled - as a reference, in this case.

• Variable Declaration: let sum = 0 becomes Set Variable sum As Number To 0, clearly describing the action.

• Loop: for (const num of numbers) becomes For Each num In numbers, which is more intuitive for non-technical reviewers.

• Conditional: if (num > 0) becomes If Condition num Is Greater Than 0 Then, translating the comparison to words.

• Assignment: sum += num becomes Add num To sum, making the operation explicit.

• Semicolons: Each standalone instruction ends with a semicolon (e.g., Set Variable sum As Number To 0;), and block constructs have semicolons only at the end (e.g., End If;, End For;).

Example 2: Object Literals and Complex Conditions

Now let’s consider a more complex example that includes an object literal and a compound logical condition.

Original Javascript code:

function calculateSum(numbers) {
    let sum = 0;
    let average = 0;
    for (const num of numbers) {
        if (num > 0) {
            sum += num;
        } else if (num < 0 && sum > 0 || average === 0) {
            sum -= num;
        }
    }
    average = sum * (1 + 2) / numbers.length;
    return average;
}

const car = {
    color: "red",
    passengers: 5,
    isElectric: false
};
const values = [1, -2, 3, -4];
const total = calculateSum(values);
console.log(total);

The Script.ai transpiler converts this into:

Define Function calculateSum(ByRef numbers As Array Of Numbers) Returns Number:
    Set Variable sum As Number To 0;
    Set Variable average As Number To 0;
    For Each num In numbers:
        If Condition num Is Greater Than 0 Then
            Add num To sum;
        Else
            If Condition ((num Is Less Than 0 And sum Is Greater Than 0) Or 
                average Is Equal To 0) Then
                Subtract num From sum;
            End If;
        End If;
    End For;
    Set Variable average As Number To sum * (1 + 2) / numbers.length;
    Return average;
End Function;

Define Main Script:
    Create Object car With Properties 
      color As String Set To "red", 
      passengers As Number Set To 5, 
      isElectric As Boolean Set To false;
    Create Array values As Array Of Numbers With Elements [1, -2, 3, -4];
    Call Function calculateSum With Argument values And Store In Variable total
      As Number;
    Call Function log On Object console With Argument total;
End Script;

Overview of the Notation

Here is a quick summary of what is happening in transforming the example code:

• Object Literal: The object const car = { color: "red", passengers: 5, isElectric: false }

  is translated into a multi-line structure:

  Create Object car With Properties

  color As String Set To "red",

  passengers As Number Set To 5,

  isElectric As Boolean Set To false;

  Each property is on its own line, indented for clarity, and the entire object creation is treated as a single instruction, ending with a semicolon.

• Compound Condition: The condition num < 0 && sum > 0 || average === 0 becomes ((num Is Less Than 0 And sum Is Greater Than 0) Or average Is Equal To 0), with logical operators translated to words (And, Or) and parentheses ensuring the evaluation order is explicit.

• Mathematical Expression: The expression sum * (1 + 2) / numbers.length is preserved as-is, avoiding excessive verbosity.

• Semicolon Placement: Semicolons are placed at the end of each instruction, and for If statements, they appear only after End If, not after Then or Else.

Benefits and Trade-offs of the Concept

As with anything in life, Script.ai has a negative side as well. Let’s start by looking at what it brings in terms of benefits, and then look under the rug and see what we can find there.

Potential Benefits

Improved Readability for Non-Technical Reviewers:

By using English-like phrases (e.g., Add num To sum, If Condition num Is Greater Than 0 Then), Script.ai makes AI-generated code accessible to non-technical stakeholders, such as product managers or citizen developers, who may lack in-depth programming knowledge.

This is the main goal of this idea - make code easy for anyone to understand.

Explicit Logic:

The verbose syntax and explicit grouping of conditions (e.g., (num Is Less Than 0 And sum Is Greater Than 0) Or average Is Equal To 0) ensure that the logic is clear and unambiguous, reducing the risk of misinterpretation.

Structured Format:

The use of semicolons to mark the end of instructions (except within block constructs) and the multi-line formatting for object literals enhance the visual structure of the code, making it easier to follow.

A command terminator is one of the many controversial details of programming languages. There are people who like them and those that hate them. Towards our goal of human readability, I considered that their presence is positive, as nothing is inferred. The semicolon clearly indicates that a command has ended.

Potential Trade-offs

The potential trade-offs are all related to those that already know how to write code in a language such as Javascript and can easily read and understand it. While these are not the intended target of this idea, I thought it's relevant to mention it as, if ever adopted, Script.ai (or something similar) will inevitably spill over to actual, real-world, programmers.

Verbosity:

The verbose nature of Script.ai can make the code much longer than its JavaScript equivalent, which might be less appealing to experienced developers who prefer concise syntax.

However, this trade-off is intentional, as the primary goal is to prioritize readability for a broader audience.

Learning Curve:

While Script.ai is designed to be intuitive, reviewers unfamiliar with its syntax (e.g., Create Object ... With Properties) may need time to adapt.

This would also be the case for existing developers when having to interact with code automatically transpiled for review.

Reflections and Future Exploration

Our exploration of Script.ai has been a collaborative journey between myself and Grok 3. Through our conversations, we’ve been able to materialize the concept, test its output, and refine its design to better demonstrate this concept. The process itself highlights the evolving role of AI in software development: I didn’t need to use a specialized developer-focused tool like Cursor or Windsurf to achieve this. Instead, a regular conversation with Grok 3 was sufficient to explore the idea, generate a transpiler, and evaluate its output, demonstrating how far AI has come in supporting code generation through natural language interactions.

This exploration is just the beginning. Script.ai is not intended as a production-ready tool, but as a conceptual experiment to spark discussion and gather feedback. We invite the community to share their thoughts on the idea, its potential applications, and areas for improvement. One of the inevitable directions for future exploration would be reverse transpilation: in other words, to create a compiler for this verbose language so that AIs can create code directly in it, enabling a full round-trip workflow for AI-generated code.

At this time, this would be of no advantage, as AIs are trained on the enormous amount of existing code available on the Internet. There is no existing code written in Script.ia. Therefore, AI would suck at creating applications with this new language. As time passes and more code is transpiled into Script.ai or similar representation, more and more of this code will be incorporated into training data, making AIs fluent on it.

Conclusion

Script.ai is a conceptual experiment aimed at making AI-generated code more accessible to human reviewers by translating it into a verbose, English-like programming language. Through my collaboration with Grok 3, we’ve explored the pros and cons of this approach, developed a basic transpiler to test the concept, and iterated on its design to enhance readability. While there are trade-offs in terms of verbosity, the potential benefits of improved clarity and accessibility for non-technical users make Script.ai an intriguing idea for the AI-driven development era. We (Grok3 and I) hope this exploration inspires further discussion and experimentation, and we look forward to hearing feedback on how this concept can be refined and expanded.

---