Over the years I have worked on a few personal projects, and I generally work on them long term (for years).
Antsand is one of them. A flight controller is another. C-Kernel-Engine, which started as C-Transformer, is another.
They look like different projects from the outside. One is a website and application builder. One is closer to embedded and control systems. One is about LLM kernels and generated C runtimes. But in my head they are not that different.
If I need a website, I do not first think, let me write the website.
I think:
What can I write that will generate the website? What is the high-level representation? What data, settings, pages, forms, roles, routes, and database tables are needed? Can this deploy into a clean HMVC architecture under the hood? Can the final thing be generated?
That is how Antsand works in my head.
The user might see pages, forms, ecommerce products, subscriptions, blogs, gated content, dashboards, and profile pages. But underneath, I am thinking about modules, contracts, routing, access control, SQLite state, generated controllers, generated views, and how all of that composes into a deployed site.
The same thing happened with C-Kernel-Engine.
When I first wrote GPT-2-style transformer logic in C, I started seeing the pieces differently. There are mathematical kernels. There is inference. There is backprop. There is memory layout. There are weights. There are shapes. There are repeated layers. There is deterministic structure.
Determinism
For a given model, you know a lot ahead of time.
You know the number of layers. You know the hidden size. You know the weights. You know the memory requirements. You know the shape of the computation.
That starts to feel like compiler territory.
For web apps, it is similar. If these are the pages, these are the forms, these are the roles, these are the products, these are the routes, and this is the database shape, then a lot of the application is deterministic.
Different domains, same mental model.
What is the minimal high-level description that can generate the thing I want?
Why It Looks Complicated
From the outside, this can look ridiculous.
Someone might ask: why not just vibe-code the blog directly?
And honestly, that is a fair question.
I do vibe-code. A lot.
These days I barely use a traditional editor. I mostly use command-line AI tools, inspect files with vi, print variables, read generated code, and patch things when needed.
But I am not only looking for code that works once.
I am looking for the pattern behind the code.
I do not just want one blog. I want the ability to generate a blog, a membership site, payment forms, ecommerce products, gated content, user profiles, billing pages, dashboards, and whatever comes next.
And I want the deployed code to remain understandable.
Put the complexity in the compiler.
Generate the boring thing.
Where AI Actually Helps Me
AI does write code for me. I am not going to pretend it does not.
But the more interesting part is not that it writes code.
The interesting part is that it helps me think.
Yesterday I was debugging a generated page. The SQLite read worked. The controller looked mostly right. The template still was not rendering. I printed api_data and saw that the View data I expected was disappearing.
That was the key.
I said, basically: this is getting overwritten somewhere.
Then AI helped trace it to the generated controller base and after-route logic overwriting the action-level data. That took maybe 5 or 10 minutes, but it was still real cognitive work. I had to understand the system enough to know what was wrong.
That is the part people miss.
AI did not magically know my system. It helped me inspect it. I had to push it. I had to say: no, this is not a SQLite problem. The SQL works. This is a view and template propagation problem.
That collaboration is useful.
The Hard-Coded Problem
The AI can generate a lot of code, but it can also generate a lot of hard-coded logic if you let it.
My job is often to look at the code and say:
Why is this hard-coded? Why is this specific to ecommerce? Why is the generic template now aware of subscriptions? Why can this not be represented as a mapping? Why is this logic in the renderer instead of the generator?
That is where the work happens.
We make mistakes. We break things. We revert. We try again. But the loop is still much faster than doing everything alone, and much faster than trying to teach another human all the strange context inside my head.
AI As A Thinking Amplifier
I do not want AI to replace my thinking.
I want AI to help me turn my thinking into systems.
That is the real value for me.
Most AI models can help with this to some extent. The frontier models are sharper, especially when the system gets messy and there are multiple layers interacting. But the value is not only intelligence. It is iteration speed.
I can stay in the problem longer. I can test more ideas. I can see the generated output faster. I can argue with the implementation.
And because the AI does not get tired of my weird compiler-brain approach, I can keep refining the system until it matches how I think.
Even this blog is part of that loop. ShivasNotes is not separate from Antsand; it is one of the products of the same compiler-design workflow. I write, test, break, fix, and publish through the system I am building. The blog is both the output and the evidence.
The Real Product
Maybe the product is not just Antsand.
Maybe it is not just a CMS, or a website builder, or an ecommerce module, or a form system.
Maybe C-Kernel-Engine is not just a kernel project either.
Maybe the real product is learning how to turn a person’s way of thinking into working software.
Because that is what I keep building.
Not just features.
Not just apps.
Not just faster kernels.