What ARC Made Me Build: A Curiosity-Driven Experiment in Symbolic Reasoning
A few months ago I became obsessed with a simple question: what if intelligence has a primitive?
Not intelligence as personality, memory or conversation. Something smaller. More fundamental. Almost like a DNA strand for reasoning itself.
Current language models are incredibly impressive, but they also seem to depend on enormous amounts of data, scale and computation. That never fully felt like the true essence of intelligence to me. I kept wondering whether there was a smaller core hidden underneath all of it. Some minimal structure capable of learning a rule from only a few examples.
That curiosity eventually led me to the Abstraction and Reasoning Corpus created by François Chollet.
The ARC tasks looked deceptively simple: small colored grids, a few input-output examples, and a hidden transformation rule that had to be inferred and applied to a new case.
But something about them felt fundamentally different from most AI systems I had seen.
The tasks were tiny, almost toy-like, but they carried a strange philosophical weight. They were not really about memorization. They were about abstraction. About detecting structure. About finding the simplest explanation that fits the evidence.
I could not stop thinking about them.
Building something I could barely explain
So I started experimenting.
Not as a researcher. Not as a serious attempt to solve ARC competitively. Just out of curiosity.
I am not a highly skilled programmer. I come from design, web development and systems thinking. I can write HTML, CSS and some JavaScript, but I could never manually engineer this kind of system from scratch.
What changed recently is that people like me suddenly gained access to something new: AI coding agents.
So night after night, I started exploring ideas conversationally with tools like Claude and Codex. Asking questions. Testing assumptions. Breaking things. Starting over. Trying to understand whether some kind of symbolic reasoning layer could emerge from simple primitives.
At first the whole thing was honestly messy and half-philosophical. I was less interested in building a product than understanding whether this style of reasoning could exist at all.
Eventually the system started solving some ARC-like tasks.
Nothing groundbreaking. But enough to become interesting.
It could detect patterns. Infer transformations. Apply symbolic rules. Sometimes surprisingly well.
That was the moment the project became dangerous for my attention span.
The moment everything changed
Because once the engine solved a few non-trivial puzzles, I asked the obvious question: could this architecture do anything useful in the real world?
The answer I got from multiple AI systems was basically:
"No. This is mostly useful for solving abstract reasoning puzzles."
I remember staring at that answer thinking:
That cannot be true.
If a machine can infer hidden structure from tiny examples and apply deterministic reasoning to unfamiliar situations, there has to be some real-world class of problems where that matters.
So I kept digging.
At first I explored ideas that felt technically possible but emotionally dead. One version became a redaction tool. Another became generic transformation pipelines. Everything felt strangely boring compared to the underlying idea itself.
Then I stumbled into Programming by Example.
And suddenly the entire thing clicked into place.
From ARC puzzles to structured data
A JSON transformation problem is not that different from an ARC task.
You show an input. You show a desired output. The system infers the transformation rule.
Rename fields. Extract structures. Merge values. Convert formats. Detect patterns.
The grids disappeared, but the reasoning loop stayed the same.
That realization changed the entire direction of the project.
The more I explored it, the more it felt like the architecture itself was strangely flexible. The symbolic reasoning layer that originally existed only to solve abstract puzzles suddenly seemed capable of operating on structured data in general.
Not because it understands the world. Not because it is AGI. But because pattern detection and structural inference are surprisingly powerful primitives.
Now I find myself in a strange position.
What started as late-night curiosity about the primitive structure of intelligence slowly evolved into an experimental data translation engine that attempts to infer transformations from examples.
JSON to JSON. CSV to JSON. Potentially much more over time.
By my research, there still seem to be surprisingly few real-world tools built around this style of symbolic example-based reasoning. Most ARC-related work appears focused on benchmarks, papers or solver research itself.
That is partly why this project became so fascinating to me.
It felt like there was a gap between the philosophical idea behind ARC and practical user-facing systems built on top of similar principles.
Honesty about what this actually is
I still do not know how far this idea really scales.
That uncertainty is important.
I am not claiming to have discovered a revolutionary architecture. I am not claiming this solves intelligence. I am not claiming to compete with research labs.
Honestly, I still feel more like a curious observer than an expert.
The entire project emerged through hundreds of hours of exploration with AI coding agents. I did not manually engineer this system from scratch. The architectural direction, the questions, the experimentation and the obsession came from me, but the implementation itself was heavily AI-assisted.
I think that honesty matters.
Because in some ways, that is also part of the story.
Five years ago I could not have explored ideas like this at all. The distance between curiosity and implementation was simply too large. You either had deep research knowledge or you stayed outside the field entirely.
Now the situation feels different.
A person with strong curiosity, systems intuition and enough persistence can suddenly explore ideas that previously belonged almost exclusively to researchers and highly specialized engineers.
That does not mean AI magically builds things on its own.
The architectural thinking still matters. Taste still matters. Direction still matters. Knowing which questions are interesting still matters.
But the distance between imagination and implementation has collapsed dramatically.
And I think that is partially why this project exists at all.
Beyond benchmarks
I started wondering whether these symbolic reasoning ideas extend beyond benchmarks into real-world systems.
Not necessarily because it leads directly to AGI, but because it points toward a different kind of intelligence than the one dominating most public AI conversations.
Something smaller. More symbolic. More deterministic. More inspectable. More structural.
Most AI products today feel probabilistic and opaque. You prompt them and hope they behave correctly.
What fascinated me about ARC was almost the opposite feeling.
The system either understands the rule or it does not.
That difference stayed with me.
And maybe that is the real reason I kept following this project long after it stopped being rational.
Not because I wanted to build a startup. Not because I wanted to solve ARC. Not even because I wanted to build a universal data translator.
I just could not shake the feeling that pattern detection itself is an incredibly deep primitive.
And that somewhere inside these tiny symbolic transformations there might be a glimpse of something much larger.
Latentmachine
The project is called Latentmachine.
Right now it is still experimental, unfinished and full of open questions.
But I think the path that led here says something important on its own:
Curiosity is becoming increasingly executable.
And that may turn out to matter more than we realize.