Build the House, Then See What It Becomes
How AI is changing the economics of building, researching and thinking
I didnât set out to build a product.
I set out to scratch an itch.
I invest across Singapore and global equities, and over the years I had developed a fairly elaborate financial research workflow. Financial statements lived in one place. SGX announcements in another. Charts somewhere else. News scattered across multiple sites. Macro indicators needed another tab. Then came the spreadsheets, notes, watchlists and the inevitable trail of browser tabs.
The problem wasnât lack of information.
It was friction.
I wanted a better research surfaceâsomething that would bring the pieces together and let me think about companies rather than spend so much time moving between information islands.
So I started building one.
That became srs.rocks.
At first, it was simply a better version of my own financial desktop.
Then something unexpected happened.
The more I built, the more ideas appeared.
And that changed my understanding of what I was actually building.
The old economics of building
There was a time when turning an idea into software required a fairly large gap between the idea and the artifact.
You had an idea.
Then you wrote a specification.
Then someone designed it.
Someone else architected it.
Someone coded it.
Someone tested it.
Someone deployed it.
By the time the idea became tangible, quite a lot had happened between thinking and seeing.
That gap mattered.
Every additional step introduced cost.
Money.
Time.
Coordination.
Context switching.
And, perhaps most importantly, friction against experimentation.
An idea might be interesting, but not interesting enough to justify the cost of building it.
So we naturally became selective.
We learned to think carefully before building.
We learned to specify.
We learned to plan.
We learned to ask:
Is this idea important enough to build?
AI changes this equation.
Not because AI magically eliminates software engineering.
It doesnât.
But it dramatically reduces the cost of moving from thought to artifact.
I can describe something.
The machine can help structure it.
We can build it.
I can look at it.
And then I can decide what I think.
The loop has become dramatically shorter.
And once that loop becomes short enough, something interesting happens.
You can afford to think by building.
From building software to externalising thought
This is where I think the deeper change is.
AI is often described as a productivity multiplier.
That is true, but incomplete.
The more interesting effect is that AI can become an integrative layer between domains.
In my case, those domains include investing, financial analysis, software architecture, data engineering, interface design and writing.
Previously, moving between those domains involved considerable translation.
Now I can move conversationally.
An investment question can become a data question.
A data question can become an interface.
An interface can reveal a research problem.
That research problem can become another product feature.
The boundaries become much more permeable.
And this creates a different kind of loop:
Human â thought â externalisation â observation â new thought â externalisation again.
The software becomes part of the thinking process.
That is a subtle but important distinction.
The product is no longer merely the output of the thinking.
The product becomes an instrument for generating the next thought.
The house changes the economics
There is another consequence.
When the cost of producing individual artifacts falls, you can produce more of them.
More experiments.
More views.
More analyses.
More research.
More output.
And that creates a new problem.
If every new idea becomes another disconnected experiment, you eventually create a mess.
You have solved the economics of creation but created a problem of accumulation.
The solution, I think, is surprisingly old-fashioned.
Build a house.
Not every room needs to be designed before you start construction.
But the house needs an underlying architecture.
A place where new things can live.
A structure that allows the next idea to become a room rather than another building.
This is one reason I think the idea of a persistent software âhouseâ becomes increasingly important in an AI-assisted world.
The value isnât simply that you can build faster.
It is that the cost of adding the next idea becomes progressively smaller because the infrastructure for ideas already exists.
The new idea doesnât need to build a house.
It only needs a room.
The US 10Y that became a room
One of the clearest examples happened almost accidentally.
While working on the srs.rocks dashboard, I was decorating the interface with small market sparklines.
The top of the dashboard was becoming a kind of macro shellâa quick visual read of the environment surrounding the companies being researched.
I needed something to put into one of those slots.
I used the US 10-year Treasury yield.
It was a tiny interface decision.
But it surfaced something much larger.
Interest rates were not just another metric. The rate regime was a persistent research concern.
And if it was important enough to influence how I thought about markets, perhaps it deserved more than a tiny sparkline.
That observation led to an idea:
Focus Themes.
Instead of merely showing data, perhaps the research surface should allow me to focus attention on the structural themes currently shaping the investment landscape.
The initial themes became:
- Rate Regime
- AI
- Oil
- Construction
At the time of writing, Focus Themes is still essentially a scaffold in development.
But that isnât really the point.
The point is how it came into existence.
I did not start with a comprehensive product specification for a Focus Themes module.
I didnât have a six-month roadmap.
I didnât conduct a strategic planning exercise.
I noticed something.
The existing system made the something visible.
That observation produced the next idea.
And because the house already existed, I could build the first version of that idea in less than an hour.
That is a very different economics of innovation.
Progressive unfolding
This has changed how I think about product development.
I donât think the best approach is necessarily to specify the entire solution space upfront.
Sometimes you cannot.
More importantly, you shouldnât.
Some possibilities only become visible after the first structure exists.
So instead of:
Think â specify everything â build
I increasingly work through:
Build â use â observe â discover â extend â reconcile
Then repeat.
This is what I mean by progressive unfolding.
You build enough structure to make the next possibility visible.
Then you build that.
Then something else becomes visible.
The solution space unfolds progressively.
It is almost like exploring a landscape with a lantern.
You donât need to illuminate the entire landscape before taking the first step.
You need enough light to see the next one.
Me observing me
There is something almost recursive about this.
When I look at a system I have built, I am not simply looking at software.
I am looking at an externalisation of my own thinking.
And therefore I can observe myself through it.
Me observing me.
An idea that existed only as an intuition becomes a screen.
A relationship that existed only in my head becomes a data structure.
A workflow becomes an interface.
A mental model becomes an architecture.
And once externalised, it becomes possible to critique.
Not just intellectually.
Visually.
Operationally.
Interactively.
The artifact becomes a mirror.
And sometimes the mirror shows something that wasnât visible before.
That is where the next idea comes from.
KISS, ABC and Elegant
There is a danger here.
Progressive unfolding can easily become feature accumulation.
Every new idea can become an excuse for another layer.
Soon the house becomes a warehouse.
So I keep coming back to three principles:
KISS
Keep It Simple.
Not simplicity for its own sake.
Simplicity appropriate to the problem.
Donât build complexity merely because you can.
ABC
Always Backwards Congruent.
A new capability should remain congruent with the underlying architecture and logic that came before it.
This doesnât mean never changing the architecture.
Quite the opposite.
Architecture should evolve.
But evolution shouldnât create conceptual debris.
Every new room should still belong to the same house.
Elegant
The final test is aesthetic, but not merely visual.
The new structure should eventually feel inevitable.
When you look backwards, it should make sense that the thing ended up there.
Not:
âWe needed this feature, so we bolted it on.â
But:
âOf course this belongs here.â
That distinction matters.
Because AI makes it increasingly easy to add things.
The scarce resource is no longer necessarily the ability to build.
It is the ability to keep what you build coherent.
ABC is also a scaling principle
Iâve come to think of ABC in another way.
It has a relationship with fractal thinking.
Nature repeatedly gives us structures that remain recognisable across scale.
The pattern changes in size without necessarily losing its underlying character.
I find that useful as an architectural intuition.
Start with the smallest meaningful unit.
Then compose it.
Then compose those compositions.
Then compose the larger structures.
Atom â component â module â system â ecosystem.
The goal isnât to make every level identical.
It is to preserve the underlying relationships as the scale changes.
The whole should remain latent in the parts.
That gives me a way to scale architecture without immediately turning it into a pile of special cases.
It also gives ABC another meaning.
Backwards congruence isnât simply:
Donât break what came before.
It becomes:
Whatever you build next should still express the same underlying shape.
That is a much more powerful constraint.
And, paradoxically, a liberating one.
AI changes research economics too
This matters beyond software.
Consider financial research.
There are thousands upon thousands of listed companies.
No human analyst can deeply investigate all of them.
Historically, that meant narrowing the universe early.
You relied on screens.
Rules.
Known categories.
Familiar names.
Existing narratives.
The problem is that every narrowing mechanism can also eliminate something interesting.
AI changes the economics of breadth.
If the cost of interrogating a company falls sufficiently, you can afford to traverse much more of the universe.
Not necessarily by asking AI to make the investment decision.
Rather, by using AI to compress the cost of investigation.
That is what sits behind the 5M framework in srs.rocks.
The objective isnât to create another stock-tip engine.
It is to create a better research surface for finding, comparing and investigating companies that may become tomorrowâs Super-Returns-Stocks.
The framework provides a way to sort a very large universe.
Then the strongest candidates can be investigated more deeply.
The investor still decides.
But the search surface becomes wider.
And potentially deeper.
That is a profound change in research economics.
More output creates another problem
There is a catch.
If AI makes research and building cheaper, we will produce vastly more things.
More reports.
More dashboards.
More analyses.
More software.
More ideas.
More experiments.
That means output itself becomes cheap.
And when output becomes cheap, the infrastructure that organises output becomes valuable.
Again, we come back to the house.
The house isnât just somewhere to put software.
It is somewhere to put possibility.
A persistent system gives new ideas somewhere to land.
It provides memory.
Context.
Architecture.
Interfaces.
Data.
Conventions.
Existing components.
And, importantly, an accumulated understanding of what came before.
The next idea therefore doesnât start from zero.
It starts from everything that already exists.
That is where the compounding happens.
The economics of one person
There is another implication I find particularly interesting.
AI doesnât simply make an existing team more productive.
It changes what a sufficiently motivated individual can attempt.
A person who previously needed a team can increasingly operate across multiple layers:
Researcher. Analyst. Architect. Developer. Designer. Writer. Tester.
Not perfectly.
Not without judgment.
And certainly not without learning.
But the integration cost between these roles can fall dramatically.
That changes the boundary of what is economically viable for one person to explore.
A product that would previously have required significant capital, a team and months of coordination can become a sufficiently cheap experiment for one person to attempt.
Some experiments will fail.
Thatâs fine.
The economics of experimentation have changed.
And that may ultimately matter more than the economics of software development itself.
Software as a visualization of thought
There is an even deeper layer to all this.
Iâve increasingly come to think of software as a way of making thought-shapes visible.
We normally think of software as something functional.
It performs a task.
It processes data.
It presents information.
But software can also be an expression of how we perceive structure.
A database expresses one conception of relationships.
An interface expresses another.
An algorithm expresses a pattern.
An architecture expresses a way of decomposing a problem.
The software becomes a kind of visualizationâor virtualizationâof the structures we believe are there.
Which raises a much older question.
What are those structures?
Different traditions have given different names to the thing underneath our models.
Tao.
Reality.
Nature.
Physics.
The underlying order of things.
I donât need to resolve that question to find the idea useful.
For me, the practical chain is enough:
The-It â perception â idea â thought-shape â software â observation â new thought-shape.
Software becomes one way of interacting with our model of reality.
And AI becomes a remarkable transducer in that processâhelping translate between language, structure, code, data and interface.
The result is not that AI thinks for us.
It is that the distance between thinking and making becomes smaller.
The horse needs a harness
There is an old danger in giving a horse more speed.
It doesnât automatically make the journey better.
You need a harness.
You need direction.
You need control.
And, perhaps most importantly, you need to know where youâre going well enough to recognise when youâre going somewhere interesting.
That is how I think about AI.
The model can gallop.
But the human still supplies the direction, judgment and purpose.
Or, since 2026 happens to be the Year of the Fire Horse, perhaps the metaphor has already chosen itself.
A good harness doesnât restrict the horse.
It lets the horse pull more.
And if youâre Sagittarius, you might as well take the analogy one step further:
The better the horse, the better the harness, the further you can rideâand the further and more sharply you can shoot.
The technology provides leverage.
The architecture provides structure.
The human provides intent.
We may be entering the age of the persistent thought-machine
Perhaps this is the bigger shift.
The traditional software product is designed around a defined problem.
You identify the problem.
You specify the solution.
You build the product.
You ship it.
But an AI-assisted system can behave differently.
It can become a persistent environment for thought.
You build the initial structure.
You use it.
The structure reveals something.
You modify it.
The modification reveals something else.
The system evolves.
Not randomly.
Not necessarily according to a fixed roadmap.
But through an ongoing conversation between the human and the artifact.
That is why I am increasingly less interested in asking:
What is the final product?
And more interested in asking:
What kind of architecture allows the next good idea to emerge?
That is a different product question.
And perhaps a different philosophy of building.
The house is not finished
When I first built the srs.rocks dashboard, there were moments when I thought:
This is probably it.
It was already useful.
It already solved the problem I had started with.
It would have been perfectly reasonable to call it finished.
Then another idea appeared.
Then another.
Not because the original architecture was inadequate.
Precisely because it existed.
Once something tangible is there, you can see things that were invisible while it existed only in your head.
That may be one of the most important lessons Iâve taken from building with AI.
Donât wait until you understand everything.
Build enough to see.
Then look.
Then build again.
A different definition of âfinishedâ
Perhaps the real mistake is thinking that the purpose of building is to reach a final state.
Some software is certainly built that way.
A calculator can be finished.
A form can be finished.
A transaction system can be finished.
But some systems are better understood as living structures.
Their value comes partly from their ability to accommodate new understanding.
For those systems, âfinishedâ is almost the wrong metric.
A better question is:
Is the architecture capable of becoming more without becoming less coherent?
That is where KISS, ABC and elegance become more than design preferences.
They become survival mechanisms.
Because the future will bring more ideas.
AI guarantees that much.
The challenge is making sure those ideas donât bury the system that made them possible.
Build the house. Then see what it becomes.
That is ultimately what srs.rocks has become for me.
It started as a financial research tool.
It became a place to experiment with research methodology.
Then a place to experiment with interfaces.
Then a way to observe my own thinking.
And now it is becoming something I didnât fully specify at the beginning.
Thatâs okay.
In fact, I think thatâs the point.
The best architectures may not be the ones that perfectly predict the future.
They may be the ones that allow the future to arrive without having to tear down the house.
AI has changed the economics of building.
It is changing the economics of research.
But perhaps the more profound change is this:
It is changing the economics of thinking out loud.
When the cost of turning an idea into an artifact becomes small enough, we can externalise more of our thinking.
When we can see our thinking, we can observe it.
When we observe it, we discover things.
When we discover things, we build again.
And so the loop continues.
Think â build â observe â discover â recompose.
Progressively.
Fractally.
Backwards-congruently.
Elegantly.
Not knowing exactly where the house will end up.
But knowing that there is now a house.
And that the next idea has somewhere to stay.
This essay is part of the thinking behind srs.rocks, an independent, data-driven Alpha Research Tool built from a personal financial research workflow. The product is still evolvingâwhich, increasingly, is the point.