On my first overnight run with Codex, it reported that it had completed all five priorities, added tests and documentation, and turned the small language that ChatGPT and I had been building into the beginnings of a credible scripting runtime.
Funny enough, I ended up with more questions than answers. The main one being:
What was I actually building?
Codex had spent the night extending the project while I slept.
So by the next morning, it was more than just an explanation of how languages worked.
But it still didn’t have a defined purpose.
I Had Ten Hours of Work
My next decision came as I was getting ready to spend ten hours at work.
I told ChatGPT:
ChatGPT had presented and explained two general paths:
A language-engineering playground or a practical scripting language.
I chose the second path because I didn’t want a plaything. I wanted to actually make the language useful.
That didn’t mean the deeper language features would never matter.
It just made the immediate purpose clear.
My Actual Working Style
Something I need to explain is how the project was being built.
Up through the end of this phase, almost everything happened through one continuous ChatGPT conversation.
I didn’t start one conversation per feature or open a new chat every time Codex finished a run.
It was one chat.
That conversation contained the original question, the 200-line offer, the progressive language upgrades, the first Codex prompt, the interpretation of Codex’s output, the next roadmap decision, the naming discussion, and eventually the review of what had happened.
The workflow looked like this:
- I would choose a direction.
- ChatGPT would help formalize it into a Codex assignment.
- I’d transfer that assignment into Codex.
- Codex would operate on the project and produce a completion report.
- I’d bring the report back to the same ChatGPT conversation.
- ChatGPT and I would interpret the reported changes and decide what should happen next.
Then we’d repeat the loop.
Basically, ChatGPT held the conversational continuity, and Codex changed the implementation.
I was moving information between them while retaining final authority over the project’s direction.
At the time, I wasn’t calling this orchestration.
I was just using each system for what it seemed best at.
But in practice, I had created a manual agentic workflow before I had built agentic orchestration into any product.
Codex Wasn’t Going In Blind
The task prompt was only one part of what Codex received.
By this stage, ChatGPT and I had developed three root documents to preserve the project’s evolving direction:
The separation was simple:
VISION says what it is.
SPEC says how it works.
ROADMAP says what comes next.
That meant Codex was not being asked to infer the entire project from a single Python file or invent a product philosophy from whatever feature request I happened to paste in that day.
The vision described the purpose, design philosophy, priorities, and non-goals.
The specification described the language’s current syntax and semantics.
The roadmap preserved the intended order of development.
The immediate prompt then defined what Codex should accomplish during that specific run.
Together, they created two layers of direction:
Persistent project intent.
Current execution instructions.
Codex had autonomy over many implementation details.
It did not have unlimited authority over what the project was supposed to become.
I learned that an agent can work independently without working blindly.
Autonomy doesn’t have to mean the absence of governance.
The Project Began Remembering Itself
Before that project context was documented, most of the project’s memory lived inside the ChatGPT conversation.
ChatGPT had the context for why each feature had been added because it had participated in the entire discussion.
Codex did not automatically possess that history.
The documents transferred the durable parts of that reasoning into the project itself.
That changed the relationship between the chat and the codebase.
The chat was still the control plane.
But the project was beginning to have its own memory.
The language vision preserved purpose beyond a single prompt.
The language specification preserved the intended behavior beyond a single implementation report.
The roadmap preserved direction beyond a single coding run.
The prompts could change.
The project’s identity did not have to change with them.
Make It Practical
The next Codex prompt was explicitly focused on turning the runtime into a usable scripting language.
It established the existing architecture, ordered the next features, and defined implementation constraints:
- Do not rewrite the entire architecture.
- Do not break existing tests.
- Keep responsibilities separated.
- Prefer readable implementations.
- Avoid speculative optimization.
Figuring out the purpose of the language had changed the priority order.
I wasn’t adding features because they were interesting.
I was adding things that would make the language more practical to use.
The Run Was Not Frictionless
Codex worked while I was at my job.
Then the internet cut out.
I had to start it again.
That detail may sound minor, but it is part of the actual reality of agentic work.
The model may be capable of operating independently, but the surrounding system still matters.
Connectivity. Session persistence. The local environment. The ability to resume.
So many things that matter.
An agent’s autonomy depends on its infrastructure.
By lunch, I had another completion report.
Codex said it had completed the remaining Phase 2 work and verified it with tests, including expanding the suite from seven passing tests to fifteen.
That was Codex’s report. I, however, was still learning the difference between receiving a structured completion summary and independently validating the entire system.
But even as a report, it gave us the next state from which to reason.
So I returned it to ChatGPT.
The Loop Continued
ChatGPT interpreted the Phase 2 result as a shift from prototype toward practical tool.
It pointed to two signals in particular.
First, the project now had launchers. It was beginning to behave like something a person could run, not merely a Python file demonstrating a VM.
Second, the reported test suite was growing alongside the language instead of features simply accumulating without any validation structure.
Then ChatGPT generated the next Codex assignment.
The new priorities were:
- Precise line-and-column error reporting
- Map assignment
- A module and import system
- A standard-library directory
- File I/O built-ins
This was not a random feature list.
Each addition addressed a limitation created by the project’s new purpose.
If people were going to write real scripts, they needed errors that identified where something went wrong.
They needed data structures that could be updated, code that could be reused across files, a standard place for shared capabilities, and the ability to read and write files.
Purpose was now governing implementation.
From Running Programs to Building Programs
Codex’s next report said it had completed the priorities with nineteen passing tests.
ChatGPT identified the conceptual threshold clearly:
The language was no longer only something that could run programs.
It was becoming something a person could build programs with.
The project now had enough structure that it needed something else.
It needed a name.
Nodus
I knew the naming question was coming.
My first choice was Axon.
An axon carries impulses away from a nerve cell.
That fit the original concept perfectly:
Logic → compilation → execution → result
The name also fit the AI-native framing without calling the language something painfully obvious like “AI Script.”
Axon sounded like a real programming-language name.
But then I found the Axon Framework.
It wasn’t just a vague naming collision in some unrelated industry. Axon was already the name of an established Java framework for event-driven systems, CQRS, and event sourcing.
I probably still could have used the name.
But I could already see another problem.
At some point, I would probably create an actual framework named Axon.
So I considered shortening the language to Ax.
That would have produced a clean command and file extension:
ax run script.ax
But it lost too much of the conceptual identity. It was harder to search and easier to collide with unrelated tools.
Then I suggested another name.
Nodus.
Latin for knot or node.
That connected the language to something larger than the neural metaphor.
Nodes, networks, connections.
The Infinite Weave.
The language was already being built as a series of connected execution layers.
So Nodus fit the project that had actually emerged.
Axon described signal movement.
Nodus described the system of connections through which execution moved.
That was closer to my broader way of thinking.
And naming the language changed how the project could be described.
It was no longer tiny_vm_lang_functions.py.
It was the Nodus language.
The Nodus compiler.
The Nodus VM.
The Nodus standard library.
A name didn’t magically make the language mature.
But it anchored the purpose, architecture, and future roadmap inside a shared identity.
What the Workflow Actually Was
Looking back, it would be easy to summarize this phase by saying:
Codex built a scripting language while I was working.
And it wouldn’t be wrong, just incomplete.
The actual process was that I made decisions with ChatGPT.
ChatGPT helped formalize those decisions into project documents and implementation assignments.
Codex then operated inside those constraints.
I brought Codex’s reports back to ChatGPT.
The same conversation interpreted the reported changes and helped produce the next assignment.
ChatGPT wasn’t just writing prompts.
It was maintaining continuity across the evolution of the project.
Codex didn’t just generate code.
It executed substantial blocks of implementation against a living system.
I wasn’t just relaying messages between two tools.
I was deciding which recommendations became direction, which path the language would take, what belonged in the durable project context, and when the experiment had become something worth naming.
The authority structure was:
Human direction → persistent project intent → agentic implementation → returned evidence → human interpretation
That was the system.
By the end of that original ChatGPT conversation, the unnamed 200-line experiment had become Nodus: a scripting language with a compiler, stack VM, collections, functions, a REPL, imports, file I/O, a standard library, tests, documentation, a roadmap, and a purpose.
But the larger discovery was not only what the agents had helped me build.
It was how I had learned to work with them.
Before I built an agentic architecture, I was already operating one by hand.
What’s Next?
If you haven’t read it yet, start with the first article in the 2026 Agents Case Study Series.
By this point, the language had a name, a purpose, and a growing set of capabilities. But the project itself was still carrying pieces of its original experimental identity, and most of the development history lived inside one ChatGPT conversation.
In the next article, I’ll explore what happened when that conversation ended, why Nodus needed its first official version and Git repository, and how architecture analysis began changing the way I evaluated and preserved AI-generated work.
The next installment of the 2026 Agents Case Study Series is coming soon.
The systems discussed throughout this series are part of the Masterplan Infinite Weave ecosystem. While not every project has appeared in the story yet, you can explore the technology, examine the source code, and follow its ongoing development.
- Nodus — The programming language that began as the experiment described in this article. Explore Nodus
- A.I.N.D.Y. Runtime — The governed execution substrate supporting workflow orchestration, persistent execution, memory, and agent coordination. Explore A.I.N.D.Y. Runtime
- A.I.N.D.Y. Platform — The application platform built on the runtime, bringing the underlying capabilities into usable applications and interfaces. Explore A.I.N.D.Y. Platform
- Masterplan Infinite Weave — The broader ecosystem connecting these projects and their ongoing development.
This series builds on the ideas, experiments, and lessons documented in my earlier work.
- 2025 ChatGPT Case Study Series — The original exploration of learning, building, and executing through sustained human-AI collaboration. Read the Series
- 2025 Duality of Progress Series — An exploration of the relationships between constraints, creativity, iteration, and progress. Read the Series
Originally published at https://www.linkedin.com.
Top comments (0)