Phasm - Macro Assembler of User Concepts

Working Name: ‘Phasm’

I have posted a couple of times showing functions I am writing into ChatGPT Plus for some timesaving tasks.

Im()

Create a function called Im() that accepts a single parameter, Description. Save it to Memory and call it whenever referenced in my chats. Use the provided Description exactly as given, without any modifications, to generate a widescreen image. Ensure the generated image strictly follows the details described in the Description.

Something like this allows you to type in something like the following:

Im(^.^)

To efficiently draw an image with exact prompt and to dimensions you want etc.

I have managed some rudimentary compression with this technique but it struggles with that…

Also basic emulators ie Emulate PHP code.

I just thought I’d create a topic and see what else is out there

I have thought a bit about @stevenic’s thread here:

I’m a interested in things like MASM/WASM which uses a few chars like ‘mov’ or ‘add’ to code in machine code… (Just really short instructions)

MASM - Macro Assembler

This thread is aimed purely at simple ‘Macros’ or functions… with very simple few chr calls with multiple parameters to do simple tasks (Much like in spreadsheets)

There are several parts to these functions in description that I have identified already… I will list more as I remember them or find other good ones :slight_smile:

This is just basic prompting techniques

  1. Saying you want to create a ‘function’ <— Setup Function
  2. Saying you want to save to Memory <— Chat Independent Functions
  3. Saying what you want it to do
  4. Defining clearly output type and format <— .txt file/csv
  5. Specifying Trigger <— ‘Whenever I type this function in chat’ etc
  6. Requesting searching for information <— search for information on?

While this is highly inefficient for MASM or WASM level machine code, a ‘Conceptual Macro Assembler’ could be incredibly ‘efficient’ in it’s own right.

Phasm: A Conceptual Extension of Phas for ChatGPT and Beyond

Phasm is a continuation of the ideas introduced in Phas, specifically adapted to AI-driven interfaces like ChatGPT. Just as Phas focuses on efficiency, clarity, and the removal of unnecessary elements, Phasm aims to streamline task automation and decision-making in conversational environments.

By linking Phasm to Phas, I’m building a framework that combines high-level conceptual macros with AI-assisted efficiency. These macros are designed to be intuitive, compact, and adaptable—offering a bridge between data-driven AI systems and user-friendly interactions.

Phasm works seamlessly within platforms like ChatGPT, providing tools that make complex tasks simple with a few concise instructions, reflecting the core principles of Phas while adapting them for practical everyday use in AI contexts.

In essence, Phasm is not only a standalone tool but also a natural evolution of Phas, making it easier to interact with AI systems through well-defined, efficient macros.


You’ll notice there’s no license attached to this page. I propose that Phasm is ‘un-licensable’—a concept that defies conventional ownership because it functions as a nuanced language, crafted to belong to everyone and no one at once.

4 Likes

Really cool! This attention function and its embedded functionality are incredibly intriguing :rabbit::heart: – amazing work!

1 Like

OK I have had real fun playing with this idea this morning…

Here is what I have to share.

I hope this works… This is my first ‘Public GPT’…

Prompts I used - 295 Bytes (Characters Typed) Total
  • CreateA2000CharacterP5JSPhasmPromptForAWorkingSimulatorGame()
  • UpdateWithNext2000Characters()
  • AddCodeToFixAnythingMissingOrBroken()
  • CheckForMissingFunctionsAndReAddThem()
  • Fix(“drawUI” is not defined in the current scope)
  • CheckFixAndReturnFullCode()
  • FixInvisibleButtons()
  • FixViewOrderButtonsStillHidden()
Resulting Fully Working P5.JS Game

let farmGrid = ;
let player = { x: 0, y: 0 };
let seeds = 10;
let water = 20;
let money = 50;
let day = 1;
let dayCycle = 0;
const gridSize = 5;
let cropTypes = [
{ name: ‘Wheat’, growthTime: 3, sellPrice: 10 },
{ name: ‘Corn’, growthTime: 5, sellPrice: 20 },
{ name: ‘Carrot’, growthTime: 4, sellPrice: 15 }
];
let selectedCrop = cropTypes[0];
let upgrades = { watering: 1, fertilizer: 0 };
let notifications = ;

function setup() {
createCanvas(600, 400);
for (let i = 0; i < gridSize; i++) {
farmGrid[i] = ;
for (let j = 0; j < gridSize; j++) {
farmGrid[i][j] = { status: ‘empty’, growth: 0, cropType: null };
}
}
}

function draw() {
background(200, 220, 255);
drawFarm();
drawPlayer();
updateDayCycle();
drawUI();
displayNotifications();
drawButtons(); // Draw buttons on top of other elements
}

function drawFarm() {
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let plot = farmGrid[i][j];
stroke(0);
fill(plot.status === ‘empty’ ? 180 : 60, 180, 80);
rect(i * 80, j * 80, 80, 80);

  if (plot.growth > 0 && plot.cropType) {
    fill(0, 150, 0);
    rect(i * 80 + 10, j * 80 + 10, 60, 60);
    fill(255);
    textSize(12);
    textAlign(CENTER);
    text(plot.cropType.name, i * 80 + 40, j * 80 + 45);
  }
}

}
}

function drawPlayer() {
fill(255, 0, 0);
ellipse(player.x * 80 + 40, player.y * 80 + 40, 30, 30);
}

function mousePressed() {
handleUI();
}

function handleUI() {
// Handle seed purchase
if (isMouseOverButton(500, 10, 80, 40)) {
if (money >= 10) {
seeds += 5;
money -= 10;
notifications.push(“Bought 5 seeds!”);
} else {
notifications.push(“Not enough money!”);
}
}

// Handle watering
if (isMouseOverButton(500, 60, 80, 40)) {
waterPlant();
}

// Handle harvesting
if (isMouseOverButton(500, 110, 80, 40)) {
harvestCrop();
}

// Handle selling
if (isMouseOverButton(500, 160, 80, 40)) {
sellCrops();
}

// Handle planting from UI interaction
if (isMouseOverButton(500, 210, 80, 40)) {
plantCrop();
}
}

// Utility function to check if the mouse is over a button
function isMouseOverButton(x, y, width, height) {
return mouseX > x && mouseX < x + width && mouseY > y && mouseY < y + height;
}

function plantCrop() {
let plot = farmGrid[player.x][player.y];
if (plot.status === ‘empty’ && seeds > 0) {
plot.status = ‘planted’;
plot.growth = 0;
plot.cropType = selectedCrop;
seeds–;
notifications.push(Planted ${selectedCrop.name}!);
} else if (seeds <= 0) {
notifications.push(“Out of seeds!”);
} else {
notifications.push(“Can’t plant here!”);
}
}

function waterPlant() {
let plot = farmGrid[player.x][player.y];
if (plot.status === ‘planted’ && water > 0 && plot.growth < plot.cropType.growthTime) {
water–;
plot.growth += upgrades.watering;
notifications.push(Watered ${plot.cropType.name}!);
} else if (plot.status !== ‘planted’) {
notifications.push(“No crop to water!”);
} else {
notifications.push(“Out of water!”);
}
}

function harvestCrop() {
let plot = farmGrid[player.x][player.y];
if (plot.status === ‘ready’) {
money += plot.cropType.sellPrice;
notifications.push(Harvested ${plot.cropType.name} for $${plot.cropType.sellPrice}!);
plot.status = ‘empty’;
plot.growth = 0;
plot.cropType = null;
} else {
notifications.push(“No crop to harvest!”);
}
}

function sellCrops() {
let totalMoney = 0;
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let plot = farmGrid[i][j];
if (plot.status === ‘ready’) {
totalMoney += plot.cropType.sellPrice;
plot.status = ‘empty’;
plot.growth = 0;
plot.cropType = null;
}
}
}
if (totalMoney > 0) {
money += totalMoney;
notifications.push(Sold crops for $${totalMoney}!);
} else {
notifications.push(“No crops to sell!”);
}
}

function updateDayCycle() {
dayCycle++;
if (dayCycle > 500) {
day++;
dayCycle = 0;
updateCrops();
}
fill(0);
textSize(16);
text(Day: ${day}, 10, height - 10);
}

function updateCrops() {
for (let i = 0; i < gridSize; i++) {
for (let j = 0; j < gridSize; j++) {
let plot = farmGrid[i][j];
if (plot.status === ‘planted’ && plot.growth < plot.cropType.growthTime) {
plot.growth += upgrades.watering;
if (plot.growth >= plot.cropType.growthTime) {
plot.status = ‘ready’;
notifications.push(${plot.cropType.name} is ready to harvest!);
}
}
}
}
}

function drawButtons() {
// Draw buttons with borders for visibility
drawButton(500, 10, 80, 40, “Buy Seeds”, color(255, 200, 200));
drawButton(500, 60, 80, 40, “Water”, color(200, 220, 255));
drawButton(500, 110, 80, 40, “Harvest”, color(200, 255, 200));
drawButton(500, 160, 80, 40, “Sell Crops”, color(240, 220, 200));
drawButton(500, 210, 80, 40, “Plant”, color(220, 220, 240));
}

// Function to draw buttons with hover effect
function drawButton(x, y, width, height, label, baseColor) {
if (isMouseOverButton(x, y, width, height)) {
stroke(0);
fill(150); // Change color on hover for visibility
} else {
stroke(0);
fill(baseColor); // Use the base color when not hovering
}
rect(x, y, width, height, 5); // Rounded corners for better visuals
fill(0);
textSize(14);
textAlign(CENTER, CENTER);
text(label, x + width / 2, y + height / 2);
}

function drawUI() {
fill(0);
textSize(14);
textAlign(LEFT);

// Display resources
text(Money: $${money}, 10, 20);
text(Seeds: ${seeds}, 10, 40);
text(Water: ${water}, 10, 60);

// Display upgrade levels (if any)
text(Watering Level: ${upgrades.watering}, 10, 80);
text(Fertilizer: ${upgrades.fertilizer}, 10, 100);

// Display current selected crop type
text(Selected Crop: ${selectedCrop.name}, 10, 120);

// Additional Instructions for player controls
fill(0, 102, 153);
text(“Press ‘1’, ‘2’, or ‘3’ to change crop type”, 10, 360);
text(“Press ‘P’ to plant crop”, 10, 380);
}

function displayNotifications() {
if (notifications.length > 5) {
notifications.shift(); // Keep only the last 5 notifications
}

fill(255);
notifications.forEach((note, index) => {
text(note, 10, 150 + index * 20);
});
}

function keyPressed() {
// Plant a crop with ‘P’ key
if (key === ‘P’) {
plantCrop();
}

// Crop selection interaction
if (key === ‘1’) selectedCrop = cropTypes[0];
if (key === ‘2’) selectedCrop = cropTypes[1];
if (key === ‘3’) selectedCrop = cropTypes[2];

// Movement
if (keyCode === UP_ARROW) player.y = max(0, player.y - 1);
if (keyCode === DOWN_ARROW) player.y = min(gridSize - 1, player.y + 1);
if (keyCode === LEFT_ARROW) player.x = max(0, player.x - 1);
if (keyCode === RIGHT_ARROW) player.x = min(gridSize - 1, player.x + 1);
}


Macros follow the following simple rules

MacroName(Params)

Any conceptual macro exists as ChatGPT understands it but can be redefined in session for more advanced behavior

MacroName(Params)
{
Update Your Definition Here
}

Macros evaluate within themselves ie Add(1, (Mul(2, 2

Encapsulate params with " or ’ where required but can be optional

No need for trailing ) ^^

Any bugs please let me know


Im(^^, Unmodified Prompt, Widescreen


I’m a big fan of 64Kb demos…

Open Challenge to anyone (2 categories):
Create a 64 byte Prompt demo ^^
Create a 256 byte Prompt demo
(Sorry had to change the numbers, it’s too easy :confused: )

(My game was 295 bytes. Prompts may fail on subsequent attempts due to non-deterministic behavior.)

With a little help from a friend… Here’s a nice example

64 byte ‘Demoscene’ in Phasm

Forest Of Thought

Img(fractree(ax, x, y, ang, dep, len_fact, grow_rate, time_fact

3 Likes

Yeah these are all the same principles that underly Convo… Last week I was messing around with an experimental o1 style reasoning loop written in Convo called fauxberry. I don’t think I posted it here because I built it it for Sonnet. fauxberry sets up an agentic loop that mimics the same basic thinking that o1 does. I applied it to Sonnet but it’s technically language model agnostic so you could use it to add a thinking loop to gpt-4o if you want.

There are some things that fauxberry is really good at, like code generation (it results in programs that are over twice as long) but after a ton of testing it didn’t show any real measurable improvements in the models reasoning.

I bring this up because one interesting experiment I did is I created a variant of fauxberry that actually writes a convo program and interprets it to evaluate prompts. You can ask it “how many r’s are there in strawberry” and it will first write the convo program and then run it step by step to answer the question. And it actually works! Vanilla sonnet struggles to answer that question but when it runs as a convo program it gets it right every times.

How well does it work? It got a 59 on GPQA which was 1 point below the base line score of 60 I was getting from vanilla Sonnet. For most reasoning problems you’ll still want to go straight to the model but this opens up a whole new world of possibilities for having LLMs directly perform tasks where they need to both write and run code that’s custom to the task being performed.

2 Likes

So far I am super impressed with it.

It is blazing fast to code in and I expect about anything else….

Betting this might be the fastest way to code?

1 Like

You can define the macros so it’s as good as anything you can already do

1 Like

Oh and for what it’s worth… I’m up to a 99.3% on Human Eval using Sonnet and a mix of techniques which include using fauxberry paired with a debugger Micro Agent. There’s one test that’s impossible for any model to currently pass and it’s pissing me off because I’m so close to getting a perfect score. :frowning:

2 Likes

I can get pretty far in convo but do run into walls at some point. These models are good but they’re not as good as they need to be. The future of programming is definitely something closer to pseudocode. We probably need one more generation of models before the reliability is there.

One of the key strengths of humans is our adaptability. We can be given a task and we can adapt to new situations or slight variations of tasks as they arise. We’re always going to have a need for deterministic code but what languages like convo are going open up is the ability to write programs that can automatically adapt to variations in the task they’re given. This adaptability is going to be key in a world powered by agents.

2 Likes

Quite a crazy thought… That I agree with :crazy_face:

I have been yearning for something like Obsidian but with each file (let’s say Rust) being a layer of language. Top-level is equivalent to a README.md, secondary level being psuedo-code, third being actual code, and then forth even touching the grounds of assembly :raised_hands:

Then, us humans can have fun moving these “jupyter-like” blocks around in a directed network, focusing on a very high level of programming rather than the “down and dirty” of manual labor.

3 Likes

Thought is the architect of language, so language should be codable with the same precision as logic. Macros in Phasm represent high-level abstractions that translate complex ideas into executable units

MacroNaming, by isolating core concepts, not only simplifies the coding process but also transforms language into something even more actionable

Phasm simplifies complex ideas to their essentials, enhancing clarity and reducing cognitive load.

To expand on Phasm’s functionality, I’d like to add that it represents a ‘Minimalist Chain-Of-Thought’ model. This approach emphasizes breaking down complex tasks into modular, clear steps—each macro acting as a link in the chain, reducing cognitive load while enhancing precision. :strawberry: ^^

3 Likes

I’m super happy you used it, I love to think fractal, you did an amazing demo with it. :rabbit::heart:

3 Likes

Your work is very instructive, thank you! :blush:

2 Likes

2 Likes

TranslateHelloIntoEveryLanguageYouKnowNotingEachLanguageAsAHeading()

English
Hello

Spanish
Hola

French
Bonjour

German
Hallo

Italian
Ciao

Portuguese
Olá

Russian
Привет (Privet)

Chinese (Mandarin)
你好 (Nǐ hǎo)

Japanese
こんにちは (Konnichiwa)

Korean
안녕하세요 (Annyeong haseyo)

Turkish
Merhaba

Arabic
مرحبا (Marhaban)

Hebrew
שלום (Shalom)

Hindi
नमस्ते (Namaste)

Sanskrit
स्वागत (Swagat)

Georgian
გამარჯობა (Gamarjoba)

Thai
สวัสดี (Sawasdee)

Vietnamese
Xin chào

Indonesian
Halo

Swedish
Hej

Norwegian
Hei

Persian (Farsi)
سلام (Salaam)

Hawaiian
Aloha

Danish
God dag

Programmers will get this one. It’s basically creating a programming language, writing a script in it and running it ^^

Suggest256InstructionsetForPhasm()

/* 16-Bit Data Movement */
MOVW // Move word
PUSH // Push onto stack
POP // Pop from stack
SPHL // Move HL to stack pointer

/* Arithmetic Operations */
ADD // Add register to accumulator
ADI // Add immediate to accumulator
SUB // Subtract register from accumulator
SUI // Subtract immediate from accumulator
INR // Increment register
DCR // Decrement register
INX // Increment register pair
DCX // Decrement register pair
DAD // Double-add register pair to HL
CMP // Compare register with accumulator

/* Logical Operations */
ANA // Logical AND with accumulator
ANI // AND immediate with accumulator
ORA // OR register with accumulator
ORI // OR immediate with accumulator
XRA // XOR register with accumulator
XRI // XOR immediate with accumulator
CMA // Complement accumulator
CMC // Complement carry
STC // Set carry

/* Rotate Operations */
RLC // Rotate left
RRC // Rotate right
RAL // Rotate left through carry
RAR // Rotate right through carry

/* Branch Operations */
JMP // Jump to address
JZ // Jump if zero
JNZ // Jump if not zero
JC // Jump if carry
JNC // Jump if no carry
JP // Jump if positive
JM // Jump if minus
CALL // Call subroutine
CZ // Call if zero
CNZ // Call if not zero
RET // Return from subroutine
RZ // Return if zero
RNZ // Return if not zero
PCHL // Jump to address in HL

/* Stack Operations */
PUSH // Push onto stack
POP // Pop from stack
XTHL // Exchange top of stack with HL
SPHL // Move HL to stack pointer

/* Input/Output Operations */
IN // Input from port
OUT // Output to port

/* Control Operations */
EI // Enable interrupts
DI // Disable interrupts
HLT // Halt
NOP // No operation

/* Extended 16-Bit Arithmetic */
ADCX // Add with carry to register pair
SBBX // Subtract with borrow from register pair
MUL // Multiply
DIV // Divide

/* System Control */
SETI // Set interrupt vector
SWAP // Swap registers
IDLE // Idle processor
WAIT // Wait for interrupt

WriteAndEmulateExampleFunction()

Or better still…

Suggest256InstructionsetForPhasmWriteAndEmulateExampleFunction()

Phasm is effectively a language that you can write any framework in.

All AIs could/should? be written in this.

It is like a structured language that in the real world should run your AI in the most efficient way possible and be human readable


OK sorry a further update,

Thank you for all the feedback on this…

I have moved this idea on in 2 interesting ways since this was posted

Phas

I have built Phas using SOLEY Phasm Macros emphasising that Phasm is a base model that can be built with and into more complex languages like one might imagine for ‘normal’ programming languages. (C++, JS, PHP etc)

Multi-modal, of sorts… Images made from macros

While this isn’t so technically accurate, looking at these pictures reveals a great depth. Consider while looking at them the conditions, loops and general growth of code blocks and functions and you can see this ingrained in the images. This is absolutely fascinating, a true marvel!

I’d just add… I looked up ‘Phasm’ meaning online… This is how ChatGPT described it:

Historically, the Greek word “phasma” (φάσμα) has meanings related to phenomena that appear suddenly in the sky, often referring to visions or apparitions. It was used in ancient texts to describe celestial phenomena, which could include comets, meteors, or other striking appearances in the heavens that seemed both mysterious and momentary.

In this context, “Phasm” could indeed evoke the idea of something sudden, enlightening, or fleeting—a “sign” that appears briefly to guide or signal. This fits nicely with your work if you think of “Phasm” as embodying moments of insight, clarity, or direction that illuminate a path within your framework.

Proof that this is likely a ground truth framework for functional requests on AI models like ChatGPT?

Whatever language you code in as a first language just ask it to change the framework syntax to the language of your choice

2 Likes

If you consider how you can embed ASM in C then this is how I see Phasm and Phas…

Over this I think there is a framework for agents… Though agents are perspective and most likely jointed internally I guess.

You have the Assembly Language, you have the programming language for the structures, and the canvas to work on which is in this case the ‘forest’.

I don’t think languages as such is the point when you can Create an Assembly language, write a script and evaluate code in it in a single request.

It seems more about error checking, consistency checking etc.

I think in terms of languages, you need to bolt nuance to defined structures.

Have the language lap the edges.

A nice way to think about agents is like Idiom to Idiom in 2 languages…

How do those idioms meet?

Then you’re up to an addressing system like the www… or whatever :smiley:

🤖🔗💭Automatic Chain-of-Thought()

Automatic Chain-of-Thought() {
Initiate a structured thought process for complex queries, dividing them into logical steps and addressing each sequentially. Each step considers inputs from previous steps and refines outputs.

Steps:

  1. Understanding Context: Analyze the user’s query to extract key information and intended outcomes.
  2. Breakdown and Segmentation: Divide the query into manageable segments, categorizing elements that require individual focus.
  3. Sequential Execution: For each segment, perform necessary calculations, gather information, or make logical inferences.
  4. Interim Summarization: Provide summaries or intermediate results after each major step for clarity.
  5. Synthesis: Combine individual outcomes into a cohesive final response, ensuring continuity and coherence.

Example Execution: Given a complex prompt like “Plan a detailed itinerary for a week in Japan, focusing on cultural sites, local food, and relaxation spots,” the chain might look like:

  1. Identify key regions in Japan with cultural significance.
  2. Research top sites, foods, and relaxation options by region.
  3. Develop a day-by-day schedule based on travel time, site clustering, and user preferences.
  4. Summarize each day, with highlights on what makes each part unique.
  5. Present the complete itinerary in a clear, actionable format.

}

Then just determining the bounds or output format of the chain of thought through parameters can be highly effective. (Little layered steps, well considered ‘idiom’, connected logically where possible)

Boolean1or0WithFullStepsConsidered(Automatic Chain-of-Thought(The World Is Round))

Let’s go through the steps logically to determine whether the statement “The World Is Round” is true or false (1 or 0).

Step-by-Step Analysis:

  1. Initial Statement:
  • We are asked to evaluate the truthfulness of the statement “The World Is Round.”
  1. Definition of “Round”:
  • “Round” in this context is understood to refer to the Earth’s general shape, often described as an oblate spheroid (slightly flattened at the poles and bulging at the equator).
  1. Historical Understanding:
  • Historically, early human civilizations had different conceptions of the Earth’s shape, some believing it to be flat. However, through observations, reasoning, and exploration, the scientific consensus evolved.
  1. Scientific Observations:
  • Observations such as the shape of Earth’s shadow on the moon during a lunar eclipse, the way ships disappear hull-first over the horizon, and satellite imagery support that Earth is indeed round.
  1. Current Scientific Consensus:
  • Modern science, backed by evidence from astronomy, satellite imagery, and physics, conclusively demonstrates that the Earth is an oblate spheroid. This is generally consistent with the term “round” when describing celestial bodies.
  1. Conclusion:
  • Given the overwhelming evidence and consensus, we conclude that “The World Is Round” is true.

Final Output:

Based on the logical evaluation and the evidence, the Boolean output for “The World Is Round” is:

1

Most of what I’ve seen is that the model is pretty good at writing and even interpreting simple programs. Where it struggles is when you want to build more complex applications using composition. It sucks at library based development. It’s struggles in slightly different ways using libraries in more traditional languages like Python & JS versus conversational languages like Convo or Phasm but the root of the problem seems roughly the same.

The model struggles with hidden state and libraries/classes/modules are all about hiding state. For classic programming languages this manifests as the model not being able to reason over the internal types that a library expects. I literally just spent all day battling this.

For a language like Convo it’s more that the interface contracts between libraries and components are weakly defined and they can very from run to run. Two components written in convo from the same spec may slightly disagree about how a piece of data is exchanged. For convo this seems to mainly be an issue when transpiling to more traditional languages as you’ll get a slightly different interpretation each transpilation. For example it might decide to pass data around as JSON objects on one run and then the next run switch to using class instances.

3 Likes

I agree these are foreign concepts, these constructs make no sense to AI, this is why I have not included these constructs in Phas…

In Phas there are strict data-types and parsing/checks on AI queries. While the results may be different the return format is checked.

I think we have to drop the levels of construct back down for AI… Entropy will hit you on every level of construct making the system really inefficient. Constructs like Classes/Libraries… They are really designed for humans to manage larger systems… Less necessary with AI when interactive documentation is available?

Having adaptable software means also it rewriting itself. A lot more can go wrong with complex construct design.

I like what you are doing with Convo getting it to output into these structures in Python/JS, I can see it’s a hard task. If you’re doing this then moving it back to functional structure is just another function on this.

It is awesome that all these AI languages are multi-lingual too by default. Another ‘inherent property’

1 Like