How Sekura Noda helps me develop a programming language, an operating system, and a processor architecture with AI.
I am working on four connected projects:
- Sekura Noda — a knowledge system for humans and AI;
- Sekura JS — a system programming language;
- Reganta OS — a micro operating system;
- Memora8 — a processor architecture.
At first, these may look like four separate projects.
In practice, they exposed the same fundamental problem:
A complex system cannot be developed reliably when its knowledge exists only in a person’s memory, source code, documents, and AI conversations.
That problem led me to build Sekura Noda.
AI can help, but it does not remember the project correctly
AI tools are extremely useful in software development.
They can help analyze architecture, generate code, compare alternatives, explain decisions, and find contradictions.
But every new conversation begins with limited context.
The AI may know general programming principles, but it does not automatically know:
- which architectural decisions I accepted;
- which ideas I rejected;
- which terms have a specific meaning inside the project;
- which older decisions have been replaced;
- why the system was designed this way.
A long conversation does not solve the problem.
Important information becomes mixed with temporary ideas, incorrect assumptions, abandoned experiments, and generated suggestions.
Documents do not completely solve it either. A document may contain many ideas, but it does not clearly show which individual statements are still valid.
Source code is also insufficient. It shows what is implemented, but often not why a decision was made.
Knowledge needs its own layer
Sekura Noda treats knowledge as a separate part of the system.
Its basic unit is a short canonical article describing one idea:
- a definition;
- an architectural rule;
- an accepted decision;
- a constraint;
- a relationship between components.
Each article remains readable by a person.
It can also be reviewed, changed, connected to other articles, and used by an AI system.
The important difference is that the AI does not decide what becomes project knowledge.
A model can suggest a new idea, improve an explanation, or identify a contradiction. But a person decides whether the result should be accepted.
This creates a clear separation:
AI generates possibilities.
Humans approve knowledge.
Why ordinary RAG is not enough
Retrieval-augmented generation can find relevant fragments in documents and provide them to a language model.
That is useful, but retrieval does not establish authority.
Imagine that a project contains:
- an old specification;
- a newer design note;
- a discussion where another approach was proposed;
- source code implementing only part of the decision.
A search system can retrieve all four.
The language model can generate a convincing answer from them.
But which source represents the current architecture?
Relevance and correctness are not the same thing.
Noda adds an explicit knowledge layer where accepted decisions can be separated from drafts, rejected ideas, and outdated information.
Noda as an engineering tool
I use Noda not only as a product for organizational knowledge.
I also use it to develop my own projects.
Sekura JS requires clear definitions of modules, execution rules, and system contracts.
Reganta OS requires consistent decisions about data exchange, orchestration, software modules, and firmware.
Memora8 requires precise architectural rules about memory, pages, processors, and ownership.
These systems are too complex to keep entirely in my working memory.
They are also too interconnected to describe reliably through isolated documents.
A change in the processor architecture may affect the operating system. A change in the operating system may affect the programming language. The reasoning behind those changes must remain understandable months or years later.
Noda gives those decisions a persistent form.
Instead of asking AI to reconstruct the project from a large collection of files and conversations, I can give it access to a structured set of accepted knowledge.
Human-readable knowledge matters
Many AI systems store knowledge in forms that people cannot inspect directly:
- model weights;
- embeddings;
- vector indexes;
- hidden prompts;
- generated summaries.
These mechanisms are useful, but they should not become the only representation of important knowledge.
Project knowledge should remain readable without a specific model.
A developer should be able to inspect it.
An expert should be able to correct it.
Another AI model should be able to use it later.
The knowledge should survive changes in tools, models, and implementation technologies.
That is why Noda does not attempt to replace human-readable knowledge with AI.
It uses AI to make human knowledge more useful.
One project supports the others
Sekura JS, Reganta OS, and Memora8 are experiments in language, operating systems, and processor architecture.
Sekura Noda operates at a different level.
It preserves the knowledge required to understand and develop all of them.
The relationship is simple:
Sekura Noda
↓
accepted architectural knowledge
↓
Sekura JS
Reganta OS
Memora8
Noda does not execute programs or manage hardware.
It helps ensure that the ideas behind those systems do not disappear, contradict each other, or depend entirely on one person’s memory.
The larger question
AI makes it possible for a small team—or even one person—to explore systems that previously required much larger groups.
But increased development speed creates a new problem.
We can generate code and ideas faster than we can preserve a coherent understanding of them.
The limiting factor may no longer be the ability to produce software.
It may be the ability to maintain reliable knowledge about what we are building.
That is the problem Sekura Noda is designed to solve.
AI was used for English translation and editorial refinement. The ideas, projects, and architectural decisions described in this article are the author’s own.
Top comments (0)